The case for better watch typography (2021) Link: https://www.hodinkee.com/articles/the-case-for-better-watch-typography Discussion: https://news.ycombinator.com/item?id=38942912 (Open link)
Two phase locking (2PL) was the first of the general-purpose Concurrency Controls to be invented which provided Serializability. In fact, 2PL gives more than Serializability, it gives Opacity, a much stronger isolation l ... (12997 chars. See body)
Two phase locking (2PL) was the first of the general-purpose Concurrency Controls to be invented which provided Serializability. In fact, 2PL gives more than Serializability, it gives Opacity, a much stronger isolation level.
2PL was published in 1976, which incidentally is the year I was born, and it is likely that Jim Gray and his buddies had this idea long before it was published, which means 2PL first came to existence nearly 50 years ago. 
After all that time has passed, is this the best we can do?
Turns out no, we can do better with 2PLSF, but let's start from the begining
When I use the term "general-purpose concurrency control" I mean an algorithm which allows access multiple objects (or records or tuples, whatever you want to name them) with an all-or-nothing semantics. In other words, an algorithm that lets you do transactions over multiple data items.
Two-Phase Locking has several advantages over the other concurrency controls that have since been invented, but in my view there are two important ones: simplicity and a strong isolation level.
In 2PL, before accessing a record for read or write access, we must first take the lock that protects this record.
During the transaction, we keep acquiring locks for each access, and only at the end of the transaction, when we know that no further accesses will be made, can we release all the locks. Having an instant in time (i.e. the end of the transaction) where all the locks are taken on the data that we accessed, means that there is a linearization point for our operation (transaction), which means we have a consistent view of the different records and can write to other records all in a consistent way. It doesn't get much simpler than this.
Today, this idea may sound embarrassingly obvious, but 50 years ago many database researchers thought that it was ok to release the locks after completing the access to the record. And yes, it is possible to do so, but such a concurrency control is not serializable.
As for strong isolation, database researchers continue to invent concurrency controls that are not serializable, and write papers about it, which means Serializability is not that important for Databases. On the other hand, all transactional commercial databases that I know of, use 2PL or some combination of it with T/O or MVCC.
Moreover, in the field of concurrency data structures, linearizability is the gold standard, which means 2PL is used heavily. If we need to write to multiple nodes of a data structure in a consistent way, we typically need something like 2PL, at least for the write accesses. The exception to this are lock-free data-structures, but hey, that's why (correct) lock-free is hard!
Ok, 2PL is easy to use and has strong isolation, so this means we're ready to go and don't need anything better than 2PL, right?
I'm afraid not. 2PL has a couple of big disadvantages: poor read-scalability and live-lock progress.
The classic 2PL was designed for mutual exclusion locks, which means that when two threads are performing a read-access on the same record, they will conflict and one of them (or both) will abort and restart.
This problem can be solved by replacing the mutual exclusion locks with reader-writer locks, but it's not as simple as this.
Mutual exclusion locks can be implemented with a single bit, representing the state of locked or unlocked.
Reader-writer locks also need this bit and in addition, need to have a counter of the number of readers currently holding the lock in read mode. This counter needs enough bits to represent the number of readers. For example, 7 bits means you can have a maximum of 128 threads in the system, in case they all decide to acquire the read-lock on a particular reader-writer lock instance.
For such a scenario this implies that each lock would take 1 byte, which may not sound like much, but if you have billions of records in your DB then you will need billions of bytes for those locks. Still reasonable, but now we get into the problem of contention on the counter.
Certain workloads have lots of read accesses on the same data, they are read-non-disjoint. An example of this is the root node of a binary search tree, where all operations need to read the root before they start descending the nodes of the tree.
When using 2PL, each of these accesses on the root node implies a lock acquisition and even if we're using read-writer locks, it implies heavy contention on the lock that protects the root node.
Previous approaches have taken a stab at this problem, for example TLRW by Dave Dice and Nir Shavit in SPAA 2010.
By using reader-writer locks they were able to have much better performance than using mutual exclusion locks, but still far from what the optimistic concurrency controls can achieve.
Take the example of the plot below where we have an implementation similar to TLRW with each read-access contending on a single variable of the reader-writer lock, applied to a binary search tree, a Rank-based Relaxed AVL. Scalability is flat regardless of whether we're doing mostly write-transactions (left side plot) or just read-transactions (right side plot).
Turns out it is possible to overcome this "read-indicator contention" problem through the usage of scalable read-indicators. Our favorite algorithm is a reader-writer lock where each reader announces its arrival/departure on a separate cache line, thus having no contention for read-lock acquisition. The downside is that the thread taking the write-lock must scan through all those cache lines to be able to ascertain whether if the write-lock is granted, thus incurring a higher cost for the write-lock acquisition.
As far as I know, the first reader-writer lock algorithms with this technique were shown in the paper "NUMA Aware reader-writer locks" of which Dave Dice and Nir Shavit are two of the authors, along with Irina Calciu, Yossi Lev, Victor Luchangco, and Virenda Marathe
This paper shows three different reader-writer lock algorithms, two with high scalability, but neither is starvation-free.
So what we did was take some of these ideas to make a better reader-writer lock, which also scales well for read-lock acquisition but has other properties, and we used this to implement our own concurrency control which we called Two-Phase Locking Starvation-Free (2PLSF).
The reader-writer locks in 2PLSF have one bit per thread reserved for the read-lock but they are located in their own cache line, along with the bits (read-indicators) of the next adjacent locks.
Like on the "NUMA-Aware reader-writer locks" paper, the cost shifts to the write-lock acquisition which needs to scan multiple cache lines to acquire the write-lock. There is no magic here, just trade-offs, but this turns out to be a pretty good trade-off as most workloads tend to be on the read-heavy side. Even write-intensive workloads spend a good amount of time executing read-accesses, for example, during the record lookup phase.
With our improved reader-writer lock the same benchmark shown previously for the binary search tree looks very different:
With this improved reader-writer lock we are able to scale 2PL even on read-non-disjoint workloads, but it still leaves out the other major disadvantage, 2PL is prone to live-lock.
There are several variants of the original 2PL, some of these variants aren't even serializable, therefore I wouldn't call them 2PL anymore and won't bother going into that.
For the classical 2PL, there are three variants and they are mostly about how to deal with contention. They're usually named:
- No-Wait
- Wait-Or-Die
- Deadlock-detection
When a conflict is encountered, the No-Wait variant aborts the self transaction (or the other transaction) and retries again. This retry can be immediate, or it can be later, based on an exponential backoff scheme. The No-Wait approach has live-lock progress because two transactions with one attempting to modify record A and then record B, while the other is attempting to modify record B and then record A, may indefinitely conflict with each other and abort-restart without any of them ever being able to commit.
The Deadlock-Detection variant keeps an internal list of threads waiting on a lock and detects cycles (deadlocks).
This is problematic for reader-writer locks because it would require each reader to have its own list, which itself needs a (mutual exclusion) lock to protect it. And detecting the cycles would mean scanning all the readers' lists when the lock is taken in read-lock mode.
Theoretically it should be possible to make this scheme starvation-free, but it would require using starvation-free locks, and as there is no (published) highly scalable reader-writer lock with starvation-free progress, it kind of defeats the purpose. Moreover, having one list per reader may have consequences on high memory usage. Who knows, maybe one day someone will try this approach.
The Wait-Or-Die variant imposes an order on all transactions, typically with a timestamp of when the transaction started and, when a lock conflict arises, decides to wait for the lock or to abort, by comparing the timestamp of the transaction with the timestamp of the lock owner. This works fine for mutual exclusion locks as the owner can be stored in the lock itself using a unique-thread identifier, but if we want to do it for reader-writer locks then a thread-id would be needed per reader.
If we want to support 256 threads then this means we need 8 bits x 256 = 256 bytes per reader-writer lock. Using 256 bytes per lock is a hard pill to swallow!
But memory usage is not the real obstacle here. The Wait-Or-Die approach implies that all transactions have a unique transaction id so as to order them, for example, they can take a number from an atomic variable using a fetch_and_add() instruction.
The problem with this is that on most modern CPUs you won't be able to do more than 40 million fetch_and_add() operations per second on a contended atomic variable. This may seem like a lot (Visa does about 660 million transactions per day, so doing 40 million per second sounds pretty good), but when it comes to in-memory DBMS it's not that much, and particularly for concurrent data structures is a bit on the low side.
Even worse, this atomic fetch_and_add() must be done for all transactions, whether they are write-transactions or read-transactions.
For example, in one of our machines it's not really possible to go above 20 M fetch_and_add() per second, which means that scalability suckz:
To put this in perspective, one of my favorite concurrency controls is TL2 which was invented by (surprise!) none other than Dave Dice, Nir Shavit and Ori Shalev
I hope by now you know who are the experts in this stuff ;)
Anyways, in TL2 the read-transactions don't need to do an atomic fetch_and_add(), and they execute optimistic reads, which is faster than any read-lock acquisition you can think of. At least for read-transactions, TL2 can scale to hundreds of millions of transactions per second. By comparison, 2PL with Wait-Or-Die will never be able to go above 40 M tps/sec.
This means if high scalability is your goal, then you would be better off with TL2 than 2PL… except, 2PLSF solves this problem too.
In 2PLSF only the transactions that go into conflict need to be ordered, i.e. only these need to do a fetch_and_add() on a central atomic variable. This has two benefits: it means there is less contention on the central atomic variable that assigns the unique transaction id, and it means that transactions without conflicts are not bounded by the 40 M tps plateau.
This means that we can have 200 M tps running without conflict and then 40 M tps that are having conflict, because the conflicting transactions are the only ones that need to do the fetch_and_add() and therefore, and the only ones bounded by the maximum number of fetch_and_adds() the CPU can execute per second.
On top of this, the 2PLSF algorithm provides starvation-freedom.
In this post we saw some of the advantages and disadvantages of 2PL and some of the variants of 2PL.
We explained what it takes to scale 2PL: make a better reader-writer lock.
But the big disadvantage of 2PL is the live-lock progress, which some variants could seemingly resolve, but in practice they don't because they will not scale, even with a better reader-writer lock.
Then we described 2PLSF, a novel algorithm invented by me, Andreia and Pascal Felber to address these issues.
In summary, 2PLSF is what 2PL should have been from the start, a concurrency control that scales well even when reads are non-disjoint and that provides starvation-free transactions, the highest form of blocking progress there is.
Moreover, it's pretty good a solving certain kinds of conflicts, which means it can have scalability even some conflicts arise. 2PLSF is not perfect, but it's good enough, certainly better than TL2 when it comes to solving conflicts.
Despite being two-phase locking, it's as close to 2PL as a jackhammer is to a pickaxe.
2PLSF is not your grandfather's 2PL
A description of how type inference for Go works. Based on the GopherCon 2023 talk with the same title. ... (36615 chars. See body)
This is the blog version of my talk on type inference at GopherCon 2023 in San Diego, slightly expanded and edited for clarity.
Wikipedia defines type inference as follows:
Type inference is the ability to automatically deduce, either partially or fully, the type of an expression at compile time. The compiler is often able to infer the type of a variable or the type signature of a function, without explicit type annotations having been given.
The key phrase here is “automatically deduce … the type of an expression”. Go supported a basic form of type inference from the start:
const x = expr // the type of x is the type of expr
var x = expr
x := expr
No explicit types are given in these declarations,
and therefore the types of the constant and variables x on the left of = and :=
are the types of the respective initialization expressions, on the right.
We say that the types are inferred from (the types of) their initialization expressions.
With the introduction of generics in Go 1.18, Go’s type inference abilities
were significantly expanded.
In non-generic Go code, the effect of leaving away types is most pronounced in a short variable declaration.
Such a declaration combines type inference and a little bit of syntactic
sugar—the ability to leave away the var keyword—into one very compact statement.
Consider the following map variable declaration:
var m map[string]int = map[string]int{}
vs
m := map[string]int{}
Omitting the type on the left of := removes repetition and at the same time increases readability.
Generic Go code has the potential to significantly increase the number of types appearing in code: without type inference, each generic function and type instantiation requires type arguments. Being able to omit them becomes even more important. Consider using the following two functions from the new slices package:
package slices
func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)
func Sort[S ~[]E, E cmp.Ordered](x S)
Without type inference, calling BinarySearch and Sort requires explicit type arguments:
type List []int
var list List
slices.Sort[List, int](list)
index, found := slices.BinarySearch[List, int](list, 42)
We’d rather not repeat [List, int] with each such generic function call.
With type inference the code simplifies to:
type List []int
var list List
slices.Sort(list)
index, found := slices.BinarySearch(list, 42)
This is both cleaner and more compact. In fact it looks exactly like non-generic code, and type inference makes this possible.
Importantly, type inference is an optional mechanism: if type arguments make code clearer, by all means, write them down.
Inference compares type patterns, where a type pattern is a type containing type parameters. For reasons that will become obvious in a bit, type parameters are sometimes also called type variables. Type pattern matching allows us to infer the types that need to go into these type variables. Let’s consider a short example:
// From the slices package
// func Sort[S ~[]E, E cmp.Ordered](x S)
type List []int
var list List
slices.Sort(list)
The Sort function call passes the list variable as function argument for the parameter x
of slices.Sort.
Therefore the type of list, which is List, must match the type of x, which is type parameter S.
If S has the type List, this assignment becomes valid.
In reality, the rules for assignments are complicated,
but for now it’s good enough to assume that the types must be identical.
Once we have inferred the type for S, we can look at the
type constraint for S.
It says—because of the tilde ~ symbol—that the
underlying type of S
must be the slice []E.
The underlying type of S is []int, therefore []int must match []E,
and with that we can conclude that E must be int.
We’ve been able to find types for S and E such that corresponding types match.
Inference has succeeded!
Here’s a more complicated scenario where we have a lot of type parameters:
S1, S2, E1, and E2 from slices.EqualFunc, and E1 and E2 from the generic function equal.
The local function foo calls slices.EqualFunc with the equal function as an argument:
// From the slices package
// func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool
// Local code
func equal[E1, E2 comparable](E1, E2) bool { … }
func foo(list1 []int, list2 []float64) {
…
if slices.EqualFunc(list1, list2, equal) {
…
}
…
}
This is an example where type inference really shines as we can potentially leave away six type arguments, one for each of the type parameters. The type pattern matching approach still works, but we can see how it may get complicated quickly because the number of type relationships is proliferating. We need a systematic approach to determine which type parameters and which types get involved with which patterns.
It helps to look at type inference in a slightly different way.
We can reframe type inference as a problem of solving type equations. Solving equations is something that we are all familiar with from high school algebra. Luckily, solving type equations is a simpler problem as we will see shortly.
Let’s look again at our earlier example:
// From the slices package
// func Sort[S ~[]E, E cmp.Ordered](x S)
type List []int
var list List
slices.Sort(list)
Inference succeeds if the type equations below can be solved.
Here ≡ stands for is identical to,
and under(S) represents
the underlying type
of S:
S ≡ List // find S such that S ≡ List is true
under(S) ≡ []E // find E such that under(S) ≡ []E is true
The type parameters are the variables in the equations. Solving the equations means finding values (type arguments) for these variables (type parameters), such that the equations become true. This view makes the type inference problem more tractable because it gives us a formal framework that allows us to write down the information that flows into inference.
Until now we have simply talked about types having to be
identical.
But for actual Go code that is too strong a requirement.
In the previous example, S need not be identical to List,
rather List must be assignable to S.
Similarly, S must satisfy
its corresponding type constraint.
We can formulate our type equations more precisely by using specific operators that
we write as :≡ and ∈:
S :≡ List // List is assignable to S
S ∈ ~[]E // S satisfies constraint ~[]E
E ∈ cmp.Ordered // E satisfies constraint cmp.Ordered
Generally, we can say that type equations come in three forms: two types must be identical, one type must be assignable to the other type, or one type must satisfy a type constraint:
X ≡ Y // X and Y must be identical
X :≡ Y // Y is assignable to X
X ∈ Y // X satisfies constraint Y
(Note: In the GopherCon talk we used the symbols ≡A for :≡ and
≡C for ∈.
We believe :≡ more clearly evokes an assignment relation;
and ∈ directly expresses that the type represented by a type parameter must
be an element of its constraint’s type set.)
In a generic function call we may have explicit type arguments, though most of the time we hope that they can be inferred. Typically we also have ordinary function arguments. Each explicit type argument contributes a (trivial) type equation: the type parameter must be identical to the type argument because the code says so. Each ordinary function argument contributes another type equation: the function argument must be assignable to its corresponding function parameter. And finally, each type constraint provides a type equation as well by constraining what types satisfy the constraint.
Altogether, this produces n type parameters and m type equations.
In contrast to basic high school algebra, n and m don’t have to be the same for
type equations to be solvable.
For instance, the single equation below allows us to infer the type arguments for
two type parameters:
map[K]V ≡ map[int]string // K ➞ int, V ➞ string (n = 2, m = 1)
Let’s look at each of these sources of type equations in turn:
For each type parameter declaration
func f[…, P constraint, …]…
and explicitly provided type argument
f[…, A, …]…
we get the type equation
P ≡ A
We can trivially solve this for P: P must be A and we write P ➞ A.
In other words, there is nothing to do here.
We could still write down the respective type equation for completeness,
but in this case, the Go compiler simply substitutes the type arguments
for their type parameters throughout and then those type parameters are
gone and we can forget about them.
For each function argument x passed to a function parameter p
f(…, x, …)
where p or x contain type parameters,
the type of x must be assignable to the type of the parameter p.
We can express this with the equation
𝑻(p) :≡ 𝑻(x)
where 𝑻(x) means “the type of x”.
If neither p nor x contains type parameters, there is no type variable to solve for:
the equation is either true because the assignment is valid Go code,
or false if the code is invalid.
For this reason, type inference only considers types that contain type parameters of the
involved function (or functions).
Starting with Go 1.21, an uninstantiated or partially instantiated function (but not a function call) may also be assigned to a function-typed variable, as in:
// From the slices package
// func Sort[S ~[]E, E cmp.Ordered](x S)
var intSort func([]int) = slices.Sort
Analogous to parameter passing, such assignments lead to a corresponding type equation. For this example it would be
𝑻(intSort) :≡ 𝑻(slices.Sort)
or simplified
func([]int) :≡ func(S)
together with equations for the constraints for S and E from slices.Sort
(see below).
Finally, for each type parameter P for which we want to infer a type argument,
we can extract a type equation from its constraint because the type parameter
must satisfy the constraint. Given the declaration
func f[…, P constraint, …]…
we can write down the equation
P ∈ constraint
Here, the ∈ means “must satisfy constraint” which is (almost) the same as
being a type element of the constraint’s type set.
We will see later that some constraints (such as any) are not useful or
currently cannot be used due to limitations of the implementation.
Inference simply ignores the respective equations in those cases.
In Go 1.18, inferred type parameters had to all be from the same function. Specifically, it was not possible to pass a generic, uninstantiated or partially instantiated function as a function argument, or assign it to a (function-typed) variable.
As mentioned earlier, in Go 1.21 type inference also works in these cases. For instance, the generic function
func myEq[P comparable](x, y P) bool { return x == y }
can be assigned to a variable of function type
var strEq func(x, y string) bool = myEq // same as using myEq[string]
without myEq being fully instantiated,
and type inference will infer that the type argument for P must be string.
Furthermore, a generic function may be used uninstantiated or partially instantiated as an argument to another, possibly generic function:
// From the slices package
// func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S
type List []int
var list List
result := slices.CompactFunc(list, myEq) // same as using slices.CompactFunc[List, int](list, myEq[int])
In this last example, type inference determines the type arguments for CompactFunc
and myEq.
More generally, type parameters from arbitrarily many functions may need to be inferred.
With multiple functions involved, type equations may also be from or involve multiple functions.
In the CompactFunc example we end up with three type parameters and five type equations:
Type parameters and constraints:
S ~[]E
E any
P comparable
Explicit type arguments:
none
Type equations:
S :≡ List
func(E, E) bool :≡ func(P, P) bool
S ∈ ~[]E
E ∈ any
P ∈ comparable
Solution:
S ➞ List
E ➞ int
P ➞ int
At this point we have a clearer understanding of the various source of type equations,
but we have not been very precise about which type parameters to solve the equations for.
Let’s consider another example.
In the code below, the function body of sortedPrint calls slices.Sort for the sorting part.
sortedPrint and slices.Sort are generic functions as both declare type parameters.
// From the slices package
// func Sort[S ~[]E, E cmp.Ordered](x S)
// sortedPrint prints the elements of the provided list in sorted order.
func sortedPrint[F any](list []F) {
slices.Sort(list) // 𝑻(list) is []F
… // print list
}
We want to infer the type argument for the slices.Sort call.
Passing list to parameter x of slices.Sort gives rise to the equation
𝑻(x) :≡ 𝑻(list)
which is the same as
S :≡ []F
In this equation we have two type parameters, S and F.
Which one do we need to solve the type equation for?
Because the invoked function is Sort, we care about its type parameter S,
not the type parameter F.
We say that S is bound to Sort because it is declared by Sort.
S is the relevant type variable in this equation.
By contrast, F is bound to (declared by) sortedPrint.
We say that F is free with respect to Sort.
It has its own, already given type.
That type is F, whatever that is (determined at instantiation time).
In this equation, F is already given, it is a type constant.
When solving type equations we always solve for the type parameters bound to the function we are calling (or assigning in case of a generic function assignment).
The missing piece, now that we have established how to collect the relevant
type parameters and type equations, is of course the algorithm that allows
us to solve the equations.
After the various examples, it probably has become obvious that solving
X ≡ Y simply means comparing the types X and Y recursively against
each other, and in the process determining suitable type arguments for
type parameters that may occur in X and Y.
The goal is to make the types X and Y identical.
This matching process is called unification.
The rules for type identity tell us how to compare types. Since bound type parameters play the role of type variables, we need to specify how they are matched against other types. The rules are as follows:
P has an inferred type, P stands for that type.P doesn’t have an inferred type and is matched against another type
T, P is set to that type: P ➞ T.
We say that the type T was inferred for P.P matches against another type parameter Q, and neither P nor Q
have an inferred type yet, P and Q are unified.Unification of two type parameters means that they are joined together such
that going forward they both denote the same type parameter value:
if one of P or Q is matched against a type T, both P and Q are
set to T simultaneously
(in general, any number of type parameters may be unified this way).
Finally, if two types X and Y are different, the equation cannot be made
true and solving it fails.
A few concrete examples should make this algorithm clear.
Consider two types X and Y containing three bound type parameters A, B, and C,
all appearing in the type equation X ≡ Y.
The goal is to the solve this equation for the type parameters; i.e., find suitable
type arguments for them such that X and Y become identical and thus the equation
becomes true.
X: map[A]struct{i int; s []B}
Y: map[string]struct{i C; s []byte}
Unification proceeds by comparing the structure of X and Y recursively, starting at the top.
Simply looking at the structure of the two types we have
map[…]… ≡ map[…]…
with the … representing the respective map key and value types that we’re
ignoring at this step.
Since we have a map on both sides, the types are identical so far.
Unification proceeds recursively, first with the key types which are A for the X map,
and string for the Y map.
Corresponding key types must be identical, and from that we can immediately infer that
the type argument for A must be string:
A ≡ string => A ➞ string
Continuing with the map element types, we arrive at
struct{i int; s []B} ≡ struct{i C; s []byte}
Both sides are structs so unification proceeds with the struct fields.
They are identical if they are in the same order, with the same names, and identical types.
The first field pair is i int and i C.
The names match and because int must unify with C, thus
int ≡ C => C ➞ int
This recursive type matching continues until the tree structure of the two types is fully traversed, or until a conflict appears. In this example, eventually we end up with
[]B ≡ []byte => B ≡ byte => B ➞ byte
Everything works out fine and unification infers the type arguments
A ➞ string
B ➞ byte
C ➞ int
Now, let’s consider a slight variation of the previous example:
here X and Y don’t have the same type structure.
When the type trees are compared recursively, unification still successfully infers the type argument for A.
But the value types of the maps are different and unification fails.
X: map[A]struct{i int; s []B}
Y: map[string]bool
Both X and Y are map types, so unification proceeds recursively as before, starting with the key types.
We arrive at
A ≡ string => A ➞ string
also as before. But when we proceed with the map’s value types we have
struct{…} ≡ bool
The struct type doesn’t match bool; we have different types and unification (and thus type inference) fails.
Another kind of conflict appears when different types match against the same type parameter.
Here we have again a version of our initial example but now the type parameter A appears twice in X,
and C appears twice in Y.
X: map[A]struct{i int; s []A}
Y: map[string]struct{i C; s []C}
The recursive type unification works out fine at first and we have the following pairings of type parameters and types:
A ≡ string => A ➞ string // map key type
int ≡ C => C ➞ int // first struct field type
When we get to the second struct field type we have
[]A ≡ []C => A ≡ C
Since both A and C have a type argument inferred for them, they stand for those type arguments,
which are string and int respectively.
These are different types, so A and C can’t possibly match.
Unification and thus type inference fails.
Unification solves type equations of the form X ≡ Y where the goal is type identity.
But what about X :≡ Y or X ∈ Y?
A couple of observations help us out here: The job of type inference is solely to find the types of omitted type arguments. Type inference is always followed by type or function instantiation which checks that each type argument actually satisfies its respective type constraint. Finally, in case of a generic function call, the compiler also checks that function arguments are assignable to their corresponding function parameters. All of these steps must succeed for the code to be valid.
If type inference is not precise enough it may infer an (incorrect) type argument where no type may exist. If that is the case, either instantiation or argument passing will fail. Either way, the compiler will produce an error message. It’s just that the error message may be slightly different.
This insight allows us to play a bit loose with the type relations :≡ and ∈.
Specifically, it allows us to simplify them such that they can be treated
almost the same as ≡.
The goal of the simplifications is to extract as much type information as
possible from a type equation, and thus to infer type arguments where a
precise implementation may fail, because we can.
Go’s assignability rules are pretty complicated, but most of the time we can actually get by with type identity, or a slight variation of it. As long as we find potential type arguments, we’re happy, exactly because type inference is still followed by type instantiation and function invocation. If inference finds a type argument where it shouldn’t, it’ll be caught later. Thus, when matching for assignability, we make the following adjustments to the unfication algorithm:
Furthermore, the assignment direction is ignored: X :≡ Y is treated like Y :≡ X.
These adjustments apply only at the top level of a type structure: for instance, per Go’s assignability rules, a named map type may be assigned to an unnamed map type, but the key and element types must still be identical. With these changes, unification for assignability becomes a (minor) variation of unification for type identity. The following example illustrates this.
Let’s assume we are passing a value of our earlier List type (defined as type List []int)
to a function parameter of type []E where E is a bound type parameter (i.e., E is declared
by the generic function that is being called).
This leads to the type equation []E :≡ List.
Attempting to unify these two types requires comparing []E with List
These two types are not identical, and without any changes to how unification works,
it will fail.
But because we are unifying for assignability, this initial match doesn’t need to be exact.
There’s no harm in continuing with the underlying type of the named type List:
in the worst case we may infer an incorrect type argument, but that will lead to an error
later, when assignments are checked.
In the best case, we find a useful and correct type argument.
In our example, inexact unification succeeds and we correctly infer int for E.
Being able to simplify the constraint satisfaction relation is even more important as constraints can be very complex.
Again, constraint satisfaction is checked at instantiation time, so the goal here is
to help type inference where we can.
These are typically situations where we know the structure of a type parameter;
for instance we know that it must be a
slice type and we care about the slice’s element type.
For example, a type parameter list of the form [P ~[]E] tells us that whatever P is,
its underlying type must be of the form []E.
These are exactly the situations where the constraint has a
core type.
Therefore, if we have an equation of the form
P ∈ constraint // or
P ∈ ~constraint
and if core(constraint) (or core(~constraint), respectively) exists, the equation
can be simplified to
P ≡ core(constraint)
under(P) ≡ core(~constraint) // respectively
In all other cases, type equations involving constraints are ignored.
If unification is successful it produces a mapping from type parameters
to inferred type arguments.
But unification alone doesn’t ensure that the inferred types are free
of bound type parameters.
To see why this is the case, consider the generic function g below
which is invoked with a single argument x of type int:
func g[A any, B []C, C *A](x A) { … }
var x int
g(x)
The type constraint for A is any which doesn’t have a core type, so we
ignore it. The remaining type constraints have core types and they are []C
and *A respectively. Together with the argument passed to g, after minor
simplifications, the type equations are:
A :≡ int
B ≡ []C
C ≡ *A
Since each equation pits a type parameter against a non-type parameter type, unification has little to do and immediately infers
A ➞ int
B ➞ []C
C ➞ *A
But that leaves the type parameters A and C in the inferred types, which
is not helpful.
Like in high school algebra, once an equation is solved for a variable x,
we need to substitute x with its value throughout the remaining equations.
In our example, in a first step, the C in []C is substituted with the
inferred type (the “value”) for C, which is *A, and we arrive at
A ➞ int
B ➞ []*A // substituted *A for C
C ➞ *A
In two more steps we replace the A in the inferred types []*A and *A
with the inferred type for A, which is int:
A ➞ int
B ➞ []*int // substituted int for A
C ➞ *int // substituted int for A
Only now inference is done. And like in high school algebra, sometimes this doesn’t work. It’s possible to arrive at a situation such as
X ➞ Y
Y ➞ *X
After one round of substitutions we have
X ➞ *X
If we keep going, the inferred type for X keeps growing:
X ➞ **X // substituted *X for X
X ➞ ***X // substituted *X for X
etc.
Type inference detects such cycles during expansion and reports an error (and thus fails).
By now we have seen how type inference works by solving type equations with unification, followed by expansion of the result. But what if there are no types? What if the function arguments are untyped constants?
Another example helps us shed light on this situation.
Let’s consider a function foo which takes an arbitrary number of arguments,
all of which must have the same type.
foo is called with a variety of untyped constant arguments, including a variable
x of type int:
func foo[P any](...P) {}
var x int
foo(x) // P ➞ int, same as foo[int](x)
foo(x, 2.0) // P ➞ int, 2.0 converts to int without loss of precision
foo(x, 2.1) // P ➞ int, but parameter passing fails: 2.1 is not assignable to int
For type inference, typed arguments take precedence over untyped arguments.
An untyped constant is considered for inference only if the type parameter it’s assigned
to doesn’t have an inferred type yet.
In these first three calls to foo, the variable x determines the inferred type for P:
it’s the type of x which is int.
Untyped constants are ignored for type inference in this case and the calls behave exactly
as if foo was explicitly instantiated with int.
It gets more interesting if foo is called with untyped constant arguments only.
In this case, type inference considers the default types
of the untyped constants.
As a quick reminder, here are the possible default types in Go:
Example Constant kind Default type Order
true boolean constant bool
42 integer constant int earlier in list
'x' rune constant rune |
3.1416 floating-point constant float64 v
-1i complex constant complex128 later in list
"gopher" string constant string
With this information in hand, let’s consider the function call
foo(1, 2) // P ➞ int (default type for 1 and 2)
The untyped constant arguments 1 and 2 are both integer constants, their default type is
int and thus it’s int that is inferred for the type parameter P of foo.
If different constants—say untyped integer and floating-point constants—compete for the same type variable, we have different default types. Before Go 1.21, this was considered a conflict and led to an error:
foo(1, 2.0) // Go 1.20: inference error: default types int, float64 don't match
This behavior was not very ergonomic in use and also different from the behavior of untyped constants
in expressions. For instance, Go permits the constant expression 1 + 2.0;
the result is the floating-point constant 3.0 with default type float64.
In Go 1.21 the behavior was changed accordingly.
Now, if multiple untyped numeric constants are matched against the same type parameter,
the default type that appears later in the list of int, rune, float64, complex is
selected, matching the rules for constant expressions:
foo(1, 2.0) // Go 1.21: P ➞ float64 (larger default type of 1 and 2.0; behavior like in 1 + 2.0)
By now we’ve got the big picture about type inference. But there are a couple of important special situations that deserve some attention.
The first one has to do with parameter order dependencies. An important property we want from type inference is that the same types are inferred irrespective of the order of the function parameters (and corresponding argument order in each call of that function).
Let’s reconsider our variadic foo function:
the type inferred for P should be the same irrespective of the order in which
we pass the arguments s and t (playground).
func foo[P any](...P) (x P) {}
type T struct{}
func main() {
var s struct{}
var t T
fmt.Printf("%T\n", foo(s, t))
fmt.Printf("%T\n", foo(t, s)) // expect same result independent of parameter order
}
From the calls to foo we can extract the relevant type equations:
𝑻(x) :≡ 𝑻(s) => P :≡ struct{} // equation 1
𝑻(x) :≡ 𝑻(t) => P :≡ T // equation 2
Sadly, the simplified implementation for :≡ produces an order dependency:
If unification starts with equation 1, it matches P against struct; P doesn’t have a type inferred for it yet
and thus unification infers P ➞ struct{}.
When unification sees type T later in equation 2, it proceeds with the underlying type of T which is struct{},
P and under(T) unify, and unification and thus inference succeeds.
Vice versa, if unification starts with equation 2, it matches P against T; P doesn’t have a type inferred for it yet
and thus unification infers P ➞ T.
When unification sees struct{} later in equation 1, it proceeds with the underlying type of the type T inferred for P.
That underlying type is struct{}, which matches struct in equation 1, and unification and thus inference succeeds.
As a consequence, depending on the order in which unification solves the two type equations,
the inferred type is either struct{} or T.
This is of course unsatisfying: a program may suddenly stop compiling simply because arguments
may have been shuffled around during a code refactoring or cleanup.
Luckily, the remedy is fairly simple. All we need is a small correction in some situations.
Specifically, if unification is solving P :≡ T and
P is a type parameter which already has inferred a type A: P ➞ AA :≡ T is trueT is a named typethen set the inferred type for P to T: P ➞ T
This ensures that P is the named type if there is choice, no matter at which point the named type
appeared in a match against P (i.e., no matter in which order the type equations are solved).
Note that if different named types match against the same type parameter, we always have a unfication
failure because different named types are not identical by definition.
Because we made similar simplifications for channels and interfaces, they also need similar special handling. For instance, we ignore channel directions when unifying for assignability and as a result may infer a directed or bidirectional channel depending on argument order. Similar problems occur with interfaces. We’re not going to discuss these here.
Going back to our example, if unification starts with equation 1, it infers P ➞ struct{} as before.
When it proceeds with equation 2, as before, unification succeeds, but now we have exactly the
condition that calls for a correction: P is a type parameter which already has a type (struct{}),
struct{}, struct{} :≡ T is true (because struct{} ≡ under(T) is true), and T is a named type.
Thus, unification makes the correction and sets P ➞ T.
As a result, irrespective of the unification order, the result is the same (T) in both cases.
Another scenario that causes problems in a naive implementation of inference is self-recursive functions.
Let’s consider a generic factorial function fact, defined such that it also works for floating-point arguments
(playground).
Note that this is not a mathematically correct implementation of the
gamma function,
it is simply a convenient example.
func fact[P ~int | ~float64](n P) P {
if n <= 1 {
return 1
}
return fact(n-1) * n
}
The point here is not the factorial function but rather that fact calls itself with the
argument n-1 which is of the same type P as the incoming parameter n.
In this call, the type parameter P is simultaneously a bound and a free type parameter:
it is bound because it is declared by fact, the function that we are calling recursively.
But it is also free because it is declared by the function enclosing the call, which happens
to also be fact.
The equation resulting from passing the argument n-1 to parameter n pits P against itself:
𝑻(n) :≡ 𝑻(n-1) => P :≡ P
Unification sees the same P on either side of the equation.
Unification succeeds since both types are identical but there’s no information gained and P
remains without an inferred type. As a consequence, type inference fails.
Luckily, the trick to address this is simple: Before type inference is invoked, and for (temporary) use by type inference only, the compiler renames the type parameters in the signatures (but not the bodies) of all functions involved in the respective call. This doesn’t change the meaning of the function signatures: they denote the same generic functions irrespective of what the names of the type parameters are.
For the purpose of this example, let’s assume the P in the signature of fact got renamed to Q.
The effect is as if the recursive call was done indirectly through a helper function
(playground):
func fact[P ~int | ~float64](n P) P {
if n <= 1 {
return 1
}
return helper(n-1) * n
}
func helper[Q ~int | ~float64](n Q) Q {
return fact(n)
}
With the renaming, or with the helper function, the equation resulting from passing
n-1 to the recursive call of fact (or the helper function, respectively) changes
to
𝑻(n) :≡ 𝑻(n-1) => Q :≡ P
This equation has two type parameters: the bound type parameter Q, declared by the
function that is being called, and the free type parameter P, declared by the enclosing
function. This type equation is trivially solved for Q and results in the inference
Q ➞ P
which is of course what we’d expect, and which we can verify by explicitly instantiating
the recursive call (playground):
func fact[P ~int | ~float64](n P) P {
if n <= 1 {
return 1
}
return fact[P](n-1) * n
}
Conspicuously absent from our description is type inference for generic types: currently generic types must always be explicitly instantiated.
There are a couple of reasons for this. First of all, for type instantiation, type inference only has type arguments to work with; there are no other arguments as is the case for function calls. As a consequence, at least one type argument must always be provided (except for pathological cases where type constraints prescribe exactly one possible type argument for all type parameters). Thus, type inference for types is only useful to complete a partially instantiated type where all the omitted type arguments can be inferred from the equations resulting from type constraints; i.e., where there are at least two type parameters. We believe this is not a very common scenario.
Second, and more pertinent, type parameters allow an entirely new kind of recursive types. Consider the hypothetical type
type T[P T[P]] interface{ … }
where the constraint for P is the type being declared.
Combined with the ablity to have multiple type parameters that may refer to each other
in complex recursive fashion, type inference becomes much more complicated and we don’t
fully understand all the implications of that at the moment.
That said, we believe it shouldn’t be too hard to detect cycles and proceed with
type inference where no such cycles exist.
Finally, there are situations where type inference is simply not strong enough to make an inference, typically because unification works with certain simplifying assumptions such as the ones described earlier in this post. The primary example here is constraints which have no core type, but where a more sophisticated approach might be able to infer type information anyway.
These are all areas where we may see incremental improvements in future Go releases. Importantly, we believe that cases where inference currently fails are either rare or unimportant in production code, and that our current implementation covers a large majority of all useful code scenarios.
That said, if you run into a situation where you believe type inference should work or went astray, please file an issue! As always, the Go team loves to hear from you, especially when it helps us making Go even better.
The history of Vi & Vim goes hand in hand with the history of open-source software. This article looks at the historical events that shaped the evolution of these text editors. (Open link)
If you ask StackOverflow or ChatGPT, how to convert an InputStream to a String in Java, you get archaic constructs with buffered readers and tedious loops. In modern Java, you achieve this task and similar ones with a si (Open link)
Did someone say … cookies? Twitter and its partners use cookies to provide you with a better, safer and faster service and to support our business. Some cookies are necessary to use our services, improve our services, an (Open link)
If you're a bit sad like me, one of the most interesting features of iOS 15 is Focus Mode. Bringing some much-needed updates to do not disturb that went before it, and also making your phone much more customisable in dif (Open link)
(Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (194) | logout How to organize yourself as a solo founder (medium.com/jeel_shah) 135 points by gekkostate 9 hours ago | flag | hide | past | (Open link)
August 2, 2020 Pat Helland Recently, there has been a lot of interest in services. These can be microservices or just services. In each case, the service provides a function with its own code and data, and opera (Open link)
It doesn’t happen by accident. (Open link)
Almost everyone who does great work toils in relative obscurity. Performance reviews are social fiction. How do people really advance through the corporate hierarchy? (Open link)
Sometimes you have the requirement to calculate percentages on some values of your data. There are multiple ways of doing it, of course, but often people are not aware that you do not have to calculate these percentages (Open link)
I just passed my one-year anniversary of being a Senior Research Director for Database at Gartner and it’s been every bit the provocative experience I anticipated. The role has added an enjoyable, new dimension to my pro (Open link)
Given thoughtfully and at the right time, constructive criticism is extremely valuable. These tips can ensure the criticism you give is actually constructive. (Open link)
<p>I’m thrilled that we have hit an exciting milestone the Apache Kafka® community has long been waiting for: we have introduced exactly-once semantics in Kafka in the 0.11 release and […]</p> (Open link)
This is the story of Simon Wardley. Follow his journey from bumbling and confused CEO lost in the headlights of change to someone with a vague idea of what they're doing. (Open link)
Hacker News new | past | comments | ask | show | jobs | submit login How to build a website without frameworks and tons of libraries (kodingkitty.com) 471 points by KodingKitty 3 months ago | hide | past | favorite | 253 (Open link)
One of the most important things I learned from running a startup is that on a macro scale the innovation market is efficient. If the market conditions allow for a startup to arise, it’s overwhelmingly probable that mult (Open link)
選擇語言 Page not found Uh oh, we can’t seem to find the page you’re looking for. Try going back to the previous page or see our Help Center for more information Go to your feed © 2022 User Agreement Privacy Policy Comm (Open link)
Twitter is an online social networking service where users can post and read short messages called “tweets”. Most candidates will design twitter as a monolithic service in system design interviews… (Open link)
A resilient system continues to operate successfully in the presence of failures. There are many possible failure modes, and each exercises a different aspect of resilience. The system needs to… (Open link)
Listening to some songs can cause a powerful physiological response known as "frisson." What is it, and why does it happen? (Open link)
Recently I wrote how I got comfortable with writing and publishing more frequently on this website. I thought I would share some specific things I did to make writing happen for me this year. (Open link)
Sharma Podila shares from their experience migrating to asynchronous processing at scale, requiring attention to managing data loss, a highly available infrastructure, and elasticity to handle bursts. (Open link)
Welcome to the Rust Book experiment, and thank you for your participation! First, we want to introduce you to the new mechanics of this experiment. The main mechanic is quizzes: each page has a few quizzes about the pag (Open link)
Obsidian. Roam. Loqseq. Bear. OneNote. Drafts. I’ve tried them all and frankly, I feel like I’m caught in a tornado of indecision. (Open link)
I could blame it on a lot of things. On my education, or lack thereof, on the reasons why I still can’t spell worth a damn. (Open link)
Every profession has its pitfalls. Doctors, for example, are always being asked for free medical advice, lawyers are asked for legal information, morticians are told how interesting a profession that must be and then peo (Open link)
So 2023 is the year of the cloud development environment (CDE). That’s like one of the longest running jokes in tech- it’s the year of Linux on the desktop. Or maybe we’re finally approaching the time that a cloud-first (Open link)
A deep dive with five Technical Program Managers (TPM) on what the role is, how it evolved, and how engineers and managers can benefit from working with TPMs. (Open link)
A .mvn directory in the root of our project can contains some useful extras. For example we can set default Maven options or Java VM options when we run a Maven command. We can also define Maven extensions we want to add (Open link)
I happened across an interesting thread on Twitter today which posed the question about when you should intervene with alternative solutions as a table gets larger over time: It is always good practice to be proactive on (Open link)
drowning out the voice of shame with the voice of reason (Open link)
Software systems are increasingly based on data, rather than code. And a new class of tools and technologies have emerged to process data for both analytics and operational AI/ ML. (Open link)
Steve Jobs, one of the computer industry’s foremost entrepreneurs, gives a wide-ranging talk to a group of MIT Sloan School of Management students in the spr... (Open link)
A collection of Scala best practices. Contribute to alexandru/scala-best-practices development by creating an account on GitHub. (Open link)
At the Sundance Film Festival, the Cut hosted a special screening of Nisha Ganatra’s short film, Rise, followed by a panel discussion about entrepreneurship and the entertainment business. Latasha Gillespie, Alia Shawka (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Life is not short (dkb.show) 298 points by dbrereton 4 hours ago | flag | hide | past | favorite | 190 comments throwa (Open link)
“Doc comments” are comments that appear immediately before top-level package, const, func, type, and var declarations with no intervening newlines. Every exported (capitalized) name should have a doc comment. The go/doc (Open link)
Software systems are increasingly based on data, rather than code. A new class of tools and technologies have emerged to process data for both analytics and ML. (Open link)
Fallacies of distributed systems are a set of assertions made by L Peter Deutsch and others at Sun Microsystems describing false assumptions that programmers new to distributed applications invariably make. (Open link)
Recent changes in devtools show that we are approaching a new era. Here's my predictions on how DevTools 2.0 will evolve in 2022. (Open link)
Researchers are increasingly understanding how exercise affects the body and, in doing so, finding smarter ways for people to exercise smarter. (Open link)
In this post we are going to take two fascinating topics, the Monty Hall Problem and the Narrative Fallacy, and see what they can teach us about product planning. Enjoy! 1. Let’s Make a Deal A lot has been written about (Open link)
There’s been a lot of discussion about platforms recently, I talked about why I think it’s a current hot meme on the WTF Podcast with Charles Humble recently, and Sam Newman just wrote a blog post… (Open link)
An introduction to Kafka's architecture and the design mechanics that support Kafka's powerful, real-time data streaming and integration features. (Open link)
The blog post will share the four phases of Real-time Data Infrastructure’s iterative journey in Netflix (2015-2021). For each phase, we will go over the evolving business motivations, the team’s unique challenges, the (Open link)
Golang is a popular programming language with powerful features. However, one can find it complicated to organize a large codebase while juggling dependencies. Go developers sometimes have to pass… (Open link)
Is what we do development anymore? (Open link)
When most folks talk about the economics of cloud systems, their focus is on automatically scaling for long-term seasonality: changes on the order of days (fewer people buy things at night), weeks (fewer people visit the (Open link)
To capture meaning of words in their vectors, we first need to define the notion of meaning that can be used in practice. For this, let us try to understand how we, humans, get to know which w (Open link)
Is the ping of a text stealing our focus or do we just lack willpower? And could mindless scrolling ever be good for our brains? Elle Hunt unpacks some surprising truths (Open link)
A collection of generic data structures written in Go. - zyedidia/generic: A collection of generic data structures written in Go. (Open link)
Things your manager might not know (Open link)
Log in Sign up (Open link)
Troubleshooting in Kubernetes can be a daunting task. In this article you will learn how to diagnose issues in Pods, Services and Ingress. (Open link)
Small annoyances happen to all of us every day and they may not garner much sympathy due to their trivial nature—but things soon add up. (Open link)
An unlikely customer anecdote and some simple bloom filters helped a Principal Engineer solve a duplicate problem on the Prime Video homepage. (Open link)
A while back, I wrote about the fact that logs need an overhaul, and that practices that were relevant when logs were still text messages in files may no longer be relevant in an age when logs traces… (Open link)
The phrase "digital garden" is a metaphor for thinking about writing and creating that focuses less on the resulting "showpiece" and more on the process, care, and craft it takes to get there. While not everybody has or (Open link)
An 85-year-long study reveals the secret to long-term happiness. Should you try it? (Open link)
A British historian famously wrote that work expands to fill available time – but what was he actually saying about inefficiency? (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (201) | logout Is this a good book for me, now? (maryrosecook.com) 226 points by ingve 1 day ago | flag | hide | past | favorite | 52 commen (Open link)
In this post I reflect on our progress so far, and some of the interesting challenges we are facing while building the BBC’s critical digital services. If you’re a technology builder, interested in… (Open link)
Are you looking for a new approach to health? Do you want to finally get the results you have been hoping for? How do you find a practitioner that is willing to try a different approach and guide you through your journey (Open link)
Hacker News new | past | comments | ask | show | jobs | submit login Reconstructing Obsidian Features in Vim and Bash (erikjohannes.no) 80 points by wuldr 4 months ago | hide | past | favorite | 45 comments nkit 4 mo (Open link)
Painting, crosswording, hiking, birding: Our reading list breaks down why it’s worth the effort to discover what brings you joy. (Open link)
Day 4/90 My friend Luca once told me that if I wanted to make real progress with my photography, I needed to stop taking photos randomly and instead work on series. It makes a lot of sense. By focusing on speci (Open link)
I’m rewriting The Business for the next book. This piece is almost 15 years old, much has changed in negotiating an offer letter, and I have more advice on how to analyze those offers. So much advice that I am idea paral (Open link)
How small tech companies are using remote work to compete with the big guys. (Open link)
Collection of thinking tools and frameworks to help you solve problems, make decisions and understand systems. (Open link)
Oh, to have sycophants of one’s own. (Open link)
I introduced Helidon Builder in my previous article, a new tool to help you develop robust fluent builders with just a few easy-to-use annotations. In that article I mentioned how Helidon Builder is… (Open link)
Authorization? How hard can it be? I am pretty sure that others have already solved it. We are not the first ones doing microservices. It should be easy to integrate what's already out there. (Open link)
Snowflake's "Data Cloud", provided as Software-as-a-Service (SaaS), enables data storage, processing, and analytic solutions in a performant, easy to use, and flexible manner. Although cloud service providers provide the (Open link)
Code working in production is the only thing that matters. Teams should optimize for delivering code to production as quickly as possible. (Open link)
A conversation with Craig Newmark (Open link)
The Go "functional options" pattern is a way of passing options to a function. The function takes a variable number of arguments, which are themselves functions (a type like ...func(*config). I think it was first introdu (Open link)
An overview of how the InfoQ editorial team sees the Software Architecture and Design topic evolving in 2022, with a focus on what architects are designing for today. (Open link)
Reproducible builds are a set of software development practices that create an independently-verifiable path from source to binary code.https://reproducible-builds.org/Reproducible builds are important and provide benefi (Open link)
JDK 21 Release Notes JEPs JEP 430 String Templates (Preview) Enhance the Java programming language with string templates. String templates complement Java's existing string literals and text blocks by coupling literal (Open link)
Resilience engineering papers. Contribute to lorin/resilience-engineering development by creating an account on GitHub. (Open link)
There are so many brilliant posts on GPT-3, demonstrating what it can do, pondering its consequences, vizualizing how it works. With all these out there, it still took a crawl through several papers (Open link)
Regular exchanges with your “weak ties” will bring you more happiness. (Open link)
I’ve observed thousands of founders and thought a lot about what it takes to make a huge amount of money or to create something important. Usually, people start off wanting the former and end up... (Open link)
My personal guide. (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Build the Modular Monolith First (fearofoblivion.com) 64 points by kiyanwang 4 hours ago | flag | hide | past | favorite | 39 (Open link)
Unlike dogs, our feline friends are barely different from their wild ancestors – except for a few clever tricks (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (199) | logout De-cloud and de-k8s – bringing our apps back home (37signals.com) 525 points by mike1o1 1 day ago | flag | hide | past | favo (Open link)
Podman Desktop is a free alternative to Docker Desktop that’s another great option for local development use. It offers a similar feature set while remaining entirely open-source, letting you avoid the licensing implicat (Open link)
Creative and open-ended tasks, new features to a product, and research tasks seem like they should be simple. You think of a goal, you start your work, and with a lot of effort, you will be… (Open link)
Troubleshooting in Kubernetes can be a daunting task. In this article you will learn how to diagnose issues in Pods, Services and Ingress. (Open link)
I’m so smitten with learning that I fear I may be addicted to it. (Open link)
How a Google Cloud support engineer found one customer’s missing DNS packets (Open link)
When splitting big teams into two smaller teams, don't make yourself redundant. Instead, try this advice to remain impactful. (Open link)
In Zeebe.io — a horizontally scalable distributed workflow engine I explained that Zebee is a super performant, highly scalable and resilient cloud-native workflow engine (yeah — buzzwords checked!)… (Open link)
This article covers the fundamentals of Kubernetes pods, from how they function to how they are created and terminated. It also provides advice on how to deal with common problems. (Open link)
Thelonious Monk had a gift for reconciling musical experiment with the immediacy of pop. (Open link)
By “high growth”, I mean in terms of employee count and roughly doubling or more every year. Even at slower growth rates, some of the phenomena I’ll describe may be relevant. The only option where… (Open link)
Plan on a Page Checklist A brief mission statement and vision for your team. What does your team do? What is your mission? What gets you up in the morning—eager to help our customers, company, and community? What is your (Open link)
Detailed Class on Carabiners. You will learn why there are so many different Shapes / Sizes & Styles of the Carabiners. How to choose & use them Safely and a... (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (194) | logout Authorization in a Microservices World (alexanderlolis.com) 239 points by zaplin 1 day ago | flag | hide | past | favorite | (Open link)
Some books are flashes in the pan, read for entertainment and then left on a bus seat for the next lucky person to pick up and enjoy, forgotten by most after their season has passed. Others stick around, are read and re- (Open link)
(Open link)
In a way, an error message tells a story; and as with every good story, you need to establish some context about its general settings. For an error message, this should tell the recipient what the code in question was tr (Open link)
Go is a tool for managing Go source code. (Open link)
Candidates need to sidestep common interview questions. Here are the best questions to ask in an interview. (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Carefully exploring Rust as a Python developer (karimjedda.com) 118 points by EntICOnc 10 hours ago | flag | hide | past | fa (Open link)
Writing tests is common practice these days. How else would you ensure that the code does what you expect? However, some software is business-critical and simply testing a few examples is not enough. The usual workfl (Open link)
Dio Rettori discusses some of the lessons learned, challenges, and considerations of large-scale adoption for JPMorgan Chase. (Open link)
Official Post from Simon Evans, but digitally. (Open link)
2022 February 01 16:21 stuartscott 1473754¤ 1240149¤ You may have noticed that the January edition of the Convey Digest looks a little different from the previous ones - the color scheme is now based on the dominant (Open link)
Kubernetes. Nowadays, it seems companies in the industry are divided into two pools: those that already use it heavily for their production workloads and those that are migrating their workloads into… (Open link)
Mindset, 100-day plan, and balancing learning and taking action to earn trust. (Open link)
Gwen Shapira talks about how microservices evolved in the last few years, based on experience gained while working with companies using Apache Kafka to update their application architecture. (Open link)
(Open link)
(Open link)
As part of a technology-driven organization, it is certain that the expectations grow exponentially higher every time for long-term sustenance. So, there is always a demand for solutions that offer… (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (201) | logout Java 21 makes me like Java again (wscp.dev) 300 points by wscp-dev 17 hours ago | flag | hide | past | favorite | 525 comment (Open link)
JEPs in JDK 21 integrated since JDK 17 Here are all of the JEPs integrated since JDK 17, which was the previous long-term-support (LTS) release from most vendors. Preview and Incubator JEPs that were superseded by later (Open link)
(Open link)
I recently contributed to a series of fireside chats hosted by LaunchDarkly. One of the themes that we discussed was Developer Experience, and how to improve it. I was asked by one of the attendees at the EMEA event (vid (Open link)
Introduction this collection of thoughts on software development gathered by grug brain developer grug brain developer not so smart, but grug brain developer program many long year and learn some things although mostly s (Open link)
Feature flags allows you to ship code more frequently, test on production, and wow your users by revealing the feature at the right moment. (Open link)
Did you have a situation when you lost a ton of time finding a Go library for your need? In theory, you can check lists like Awesome Go or make a choice based on GitHub stars. But Awesome Go contains over 2600 libraries, (Open link)
Rely on your mediation skills, not your authority. (Open link)
A course that breaks down every aspect of modern progressive web app development. (Open link)
Join the heated discussion about this article on Hacker News 🔥 Junior Engineers care about writing Software. They value code quality, employ best pra (Open link)
Ages ago, a work colleague / friend offered me the following piece of advice: “We need to make sure you’re seen as strategic”. I’ve thought about it a lot ever since. It was the first time I realised I was on the edge (Open link)
Learn how you can use the Virtualization framework to quickly create virtual machines on your Mac. We'll show you how to create a virtual... (Open link)
A comprehensive guide to mechanical keyboard switches. It's time to fall deep into the rabbit hole. (Open link)
A data mesh architecture is a decentralized approach that enables domain teams to perform cross-domain data analysis on their own. (Open link)
Basically, sake comprises rice, water, and the fermenting agent called koji, resulting in an alcoholic level that usually sits between 13 and 16 percent. And you might be interested to know that the rice used is differen (Open link)
Personal site of Johnny Rodgers, technology designer from Vancouver. (Open link)
When someone sends you a pull request from a fork or branch of your repository, you can merge it locally to resolve a merge conflict or to test and verify the changes before merging on GitHub. (Open link)
In this article, Louis Lazaris describes and demonstrates some interesting HTML attributes that you may or may not have heard of and perhaps find useful enough to personally use in one of your projects. (Open link)
Ten years ago, I wanted to use a Lego Mindstorms NXT 2.0 kit to build a robot that could continuously monitor our software development builds. (Open link)
Disclamer: Please note that I am not a lawyer. All the information provided here related to how I've integrated ChatGPT into my workflow should be considered with caution. It is important to use your own judgement when d (Open link)
Improve Java application performance by choosing the best garbage collector for your application's throughput, latency, and footprint requirements. (Open link)
Sharon Salzberg, Judith Simmer-Brown, John Tarrant, and Dzogchen Ponlop Rinpoche discuss skillful and unskillful involvement with emotions, offering new perspectives on how to think about and engage with our emotional li (Open link)
Learn how packets flow inside and outside a Kubernetes cluster. Starting from the initial web request and down to the container hosting the application (Open link)
There is no bar for the quality of a blog post. Allow me to be an example. See… every blog post on this entire site. I’d like to write better individual blog posts, but something has always compelled me to punt out a tho (Open link)
This blog is written in Asciidoc, built using Hugo, and hosted on GitHub Pages. I recently wanted to share the draft of a post I was writing with someone and ended up exporting a local preview to a PDF - not a great work (Open link)
DetailsApril Meetup➤➤ AGENDA ➤➤6:30 - 6:40 - GoSF Announcements / Community Job Opportunities6:40 - 7:10 - Designing as a Developer in GoLang - Sushrut Athav... (Open link)
[This fragment is available in an audio version.] I’ve enjoyed writing software for 40+ years now. Lots of activities fall into that “writing software” basket, and here’s my favorite: When you have a body of code wi (Open link)
Second-order thinking is a mental model that smart people like Warren Buffett & Howard Marks use to avoid problems. Read this article to learn how it works. (Open link)
The aim of the present study was to determine the effect of different nap opportunity durations on short-term maximal performance, attention, feelings, muscle soreness, fatigue, stress and sleep. Twenty physically active (Open link)
I’m so smitten with learning that I fear I may be addicted to it. (Open link)
A new tool that blends your everyday work apps into one. It's the all-in-one workspace for you and your team (Open link)
I put this mind map together a few years ago after a discussion about what a new VP of Engineering or CTO should think about in their first 90 days in a new role. It’s a map of the areas I believe every new technical le (Open link)
JavaOne is back! ➱ https://oracle.com/javaone Java 8 launched in March of 2014, Java 18 in March of 2022. There are 8 years of progress, 203 JDK Enhancemen... (Open link)
This guide shows you how to write, structure, visualize and manage software architecture documentation using appropriate documentation tools. (Open link)
You've driven home from work along the same route for the past five years. (Open link)
Discover the three phases of software development, as depicted through 30 commit messages encountered by our community! (Open link)
When you‘re in the midst of starting a business, while also writing a book, like me and my business partner Sara currently are with The Intentional Organization, your mind can feel all over the place. It‘s constantly ove (Open link)
(Open link)
In this post, I hope to explore different forms of “testing in production”, when each form of testing is the most beneficial as well as how to test services in production in a safe way. However… (Open link)
Plan Your Next #131 (Open link)
The SQL standard defines isolation levels, but we don't have a great vocabulary for talking about consistency levels, and how these two things interact. (Open link)
A conversation with Dizzy Smith, VP of Engineering, Edge & Node (Open link)
Tom Service's survey of the 50 symphonies that changed classical music (Open link)
As software engineers, we're constantly making detailed, elaborate plans for computers to execute. Isn't it weird that we rarely give a moment's thought to the program for our own careers? (Open link)
If you think you’ll be happier staying home, you’re wrong. (Open link)
(Open link)
Resilient payments systems, large-scale data storage with OLTP and OLAP systems, platform team challenges, and more. (Open link)
By preemptively taking action if you expect to receive a bad performance review, you may be able to steer a different course for yourself and avoid a foregone conclusion — or at least feel better about the outcome. The a (Open link)
(Open link)
Tripsy is more than just an app for storing details about your upcoming trips. It does that and does it well, but it’s also a great way to revisit old trips and get inspired about places you want to visit in the future. (Open link)
Hello film friends, We know, we know. We can’t believe we are ripping through August either. But we are barreling headlong into fall festival season, bub, so get used to it. Luckily, there’s an inordinately large number (Open link)
When to use generics when writing Go code, and when not to use them. (Open link)
In the years after World War I, longtime Army colleagues and friends George S. Patton and Dwight D. Eisenhower contemplated what would happen if another global conflict broke out. As Patton envisioned it: “In the next wa (Open link)
a) why this name instead of “repeaters”, the most used name in the English-speaking world, and b) why put forward this method and compare its effects on strength and endurance with those obtained through maximum strengt (Open link)
Pleased to Meet You... Video version available on YouTube: In 2024, I’ll have been a programmer for 40 years. I’m not quite there yet, but I’ll get there. T (Open link)
I tell the sad but kinda funny tale of how I basically failed my first Google interview. (Open link)
In this article, I’ll give you some advice and best practices for dealing with Java dependencies in your project. (Open link)
Research suggests there is some heritable component of cognitive characteristics in dogs, which could have important implications for understanding the capabilities of different breeds. (Open link)
It's a state, not an outcome. (Open link)
Occam’s razor is one of the most useful, (yet misunderstood,) models in your mental toolbox to solve problems more quickly and efficiently. Here’s how to use it. (Open link)
(Open link)
(Open link)
A journey of emotional awareness, where we uncover the power of naming and visualizing your feelings. (Open link)
Learn about 6 battle-tested event-driven architecture patterns (on top of Kafka) that are used by Wix microservices (Open link)
People rarely talk about how they made it into the role of VP of Engineering. Join Emily as she opens up about the process - good and bad. (Open link)
The Diátaxis framework solves the problem of structure in technical documentation, making it easier to create, maintain and use. (Open link)
Uncover the key differences between amateurs and professionals that make a difference and improve the prospects of success. (Open link)
When hiring developers, there are many things we are looking for, but over the years I have found that raw coding ability is easily the most important quality to look for. I can quickly train a person to have knowledge (Open link)
BackgroundSkipLists often come up when discussing “obscure” data-structures but in reality they are not that obscure, in fact many of the production grade softwares actively use them. In this post I’ll try to go into Ski (Open link)
+Guest Posts: Movie Wisdom By Guest Writer Mary Tabor—Issue #10 (Open link)
When it comes to cache invalidation, we believe we now have an effective solution to bridge the gap between theory and practice. (Open link)
Here's what happened when I replaced my iPhone 14 with the Apple Watch Ultra for 24 hours. The results are surprising, to say the least. (Open link)
Tags Go , Go tooling Most tutorials on Go tooling (and probably most other tooling) tend to focus on the happy path - the input code is perfectly vali (Open link)
The Prime Video team published this story: Scaling up the audio/video monitoring service and reducing costs by 90%, and the internet piled in with opinions and bad takes, mostly missing the point… (Open link)
Credit: Andrij Borys Associates; Renee French (CC by 3.0) Go is a programming language created at Google in late 2007 and released as open source in November 2009. Since then, it has operated as a public project, wi (Open link)
When you are new to Docker, the number of commands to study might be truly overwhelming. This article shows a way to internalize the most important Docker commands without the brute-force memorization. (Open link)
An eight-week training plan that will build serious chest muscle. The workout is made up of bodyweight exercises so is perfect for a home workout plan (Open link)
Sometimes music can be so beautiful that words seem to fall short. there are tons of words to describe music that can work like a perfect pitch. (Open link)
Three distinct perspectives on scale that come along with building and operating a storage system the size of S3. (Open link)
"Hunter Thompson" redirects here. For the musician, see Hunter G. K. Thompson. Hunter S. ThompsonThompson at Caesars Palace in Las Vegas in 1971BornHunter Stockton Thompson July 18, 1937 Louisville, Kentucky, U.S.DiedFe (Open link)
A Kubernetes tutorial for complete beginners. (Open link)
It’s hardly insightful to suggest that the last few years have substantially changed the day to day experience of a knowledge worker. Nearly overnight even the most remote skeptical leadership teams were forced to embrac (Open link)
The concept behind frameworks and libraries is to provide reusable code that you can use to perform everyday tasks so that developers don't have to write (Open link)
Some tactical and strategic tips for writing effectively as a software developer. (Open link)
The 150 year old device that made a 50 year old Integrated Development Environment (IDE) rock Engelbart keyset: One handed chorded keyboard Photograph @Richard Mark courtesy of Computer (Open link)
Steve Jobs was a titan of tech. He masterminded the iMac and iPhone, and changed the world. He had a deep love of Japanese culture, from woodblock prints to ceramics, and the inner workings of electronics giant Sony. Her (Open link)
I developed this internal communications template for discussing “spicy” topics. (Open link)
Well, it’s that time once again. It’s time for a new release of the Go programming language. Go 1.18 in Q1 of 2022 was a major release that featured the long awaited addition of generics to the language and also had lots (Open link)
Despite advances in browser tooling, automated evaluation, lab tools, guidance, and runtimes, modern teams struggle to deliver even decent performance with today's popular frameworks. This is not a technical problem per (Open link)
In this article, we dive into the possibilities of mechanical keyboards. The different layouts, switch types and even keycap material. Strap yourself in — this will be a deep dive! (Open link)
GitHub Gist: instantly share code, notes, and snippets. (Open link)
At Nile, we’re making it easier for companies to build world-class control planes for their infra SaaS products. Multi-tenancy is core to all SaaS products and especially those with control-plane architectures. At Nile, (Open link)
This article has a large gap in the story: it ignores sensor data sources, which are both the highest velocity and highest volume data models by multiple orders of magnitude. They have become ubiquitous in diverse, mediu (Open link)
Oct 3, 2014 Literate programming: Knuth is doing it wrong Literate programming advocates this: Order your code for others to read, not for the compiler. Beautifully typeset your code so one can curl up in bed to read it (Open link)
"...the mere consciousness of an engagement will sometimes worry a whole day." – Charles Dickens July 2009 One reason programmers dislike meetings so much is that they're on a different type of schedule from other peo (Open link)
North Texas’ resident tech genius, John Carmack, is taking aim now at his most ambitious target: solving the world’s biggest computer-science problem by developing artificial general intelligence. That’s a form of AI who (Open link)
Manage different toggles differently As discussed earlier, there are various categories of Feature Toggles with different characteristics. These differences should be embraced, and different toggles (Open link)
sebastiandaschner blog About Workshops Courses Consulting Blog News More Contact Helpful Command Line Scripts and Automation in My Setup #productivity #commandline friday, january 06, 2023 In this video, I’ve put togethe (Open link)
0:00 / 59:52 (Open link)
4:34 / 54:09 (Open link)
In this post, understand the different concepts of consistency as applied to distributed databases, as well as some issues with the conversation of consistency. (Open link)
(Open link)
I spend way too much time on video conferences. Between my day to day at VMware, and the Kubernetes/CNCF communities I probably spend >50% of my time on Zoom. (There is an option to enable keyboard… (Open link)
Ready to switch from your Apple Watch Series 7 to the new Series 8 or SE? Or maybe you just need to transfer your existing Apple Watch with your new iPhone? Follow along for how to seamlessly pair a new or existing Apple (Open link)
5.12 climbers generally share certain strengths and skills that aspirants to the grade often need to consciously train. (Open link)
(Open link)
It's about planting doubt in your head and making you question your own reality. (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (194) | logout Rethinking Visual Programming with Go (divan.dev) 220 points by techplex 22 hours ago | flag | hide | past | favorite | 56 co (Open link)
Today, you will identify the areas of your life in which you would like to be more connected. (Open link)
From a cup of mud to a macchiato, coffee puts a spring in everyone's step (Open link)
(Open link)
As we enter the ninth iteration of watchOS, I must admit that I sometimes find myself looking back wistfully on the computer watch that the Apple Watch once was. My inner tech nerd misses the wild, blind shots at digital (Open link)
Scientific American is the essential guide to the most awe-inspiring advances in science and technology, explaining how they change our understanding of the world and shape our lives. (Open link)
(Open link)
Mercurial 5.2 was released on November 5, 2019. It is the first version of Mercurial that supports Python 3. This milestone comes nearly 11 years after Python 3.0 was first released on December 3, 2008. Speaking as a mai (Open link)
This is a summary from a recent Twitter thread I shared (which does explain the short paragraphs, I hope). (Open link)
<iframe src="https://www.youtube.com/embed/AUJAZ6L8DkE" width="560" height="315" frameborder="0" allowfullscreen="allowfullscreen"></iframe> <iframe src="https://w.soundcloud.com/player/?url=https%3A//api.soundcloud.com/ (Open link)
With millions of users and one of the most sophisticated microservice-driven platforms today, Doordash was the perfect testing ground for an automated resilience testing tool developed by Meiklejohn, and members of the C (Open link)
A resilient system continues to operate successfully in the presence of failures. There are many possible failure modes, and each exercises a different aspect of resilience. The system needs to… (Open link)
Recently, while watching a lecture by Niall Ferguson, I learned a new concept with an unfamiliar name: counterfactual history. The human mind tends to find causal narrative in everything, and we tend… (Open link)
Does this Go snippet compile, and if not, why? package main func main() { users := []User{User{"alice"}, User{"bob"}} var _ Named = User{"charlie"} getName(users[0]) getNames(users) } type Named (Open link)
In this post I want to write about probably the most powerful text editor there is: Emacs and how to set it up so you can begin programming and live coding with Overtone in no time. Many users would disagree and argue th (Open link)
There are too many task management apps to choose from today. I wanted to boil it down to my favorite 3 task managers for macOS! Here they are. (Open link)
The R/H/E box is outdated and largely unhelpful, yet it appears prominently on every major league scoreboard and TV broadcast. Here's how it got that way. (Open link)
Don't know what your core values are? Here's three ways to discover your personal values. (Open link)
Find out how to build great REST APIs in any language by following these 10 essential rules. (Open link)
Gwen Shapira talks about how microservices evolved in the last few years, based on experience gained while working with companies using Apache Kafka to update their application architecture. (Open link)
NOTE: Although I was at Spotify for around 8 years, I‘m not familiar with how every area worked and I have my own biases, preferences, etc. AND things change I will define “Spotify Model” as any… (Open link)
Negative-utilitarianism challenges the moral symmetry of pleasure and pain. It would justify erasing the world were that the only way to eradicate suffering (Open link)
(Open link)
Get started reading ''On-call with Tammy Bryant Butow'' by Elena Boroda (Open link)
October 25, 2020 A decade ago I got to sit in on a talk by one of the designers of Microsoft Office who’d worked on the transition to the new Ribbon user interface. There was a lot to learn there, but the most interes (Open link)
(Open link)
23 cubic kilometers of mountain plunged into the valley below. (Open link)
Explore how different container logging patterns in Kubernetes work. (Open link)
This article will try to decode these technologies and explore how developers should consider containers or serverless functions within their tech stack. (Open link)
September 27, 2011 — Posted in Training Goal Setting Reverse Pyramid Training Weight Training Dear readers, it is with troublesome news I break my three months of silence. The (Open link)
Checklist for success of a senior engineer (Open link)
Mindset, 100-day plan, and balancing learning and taking action to earn trust. (Open link)
Table of ContentsStep 1: Become a UserStep 2: Build the ProjectStep 3: Learn the Hot-Path InternalsTrace DownLearn UpExperiment and Break ThingsSupplement with MediaStep 4: Read and Reimplement Recent CommitsStep 5: Make (Open link)
(Open link)
(Open link)
Information Theory is one of the most useful things for Computer Scientists to understand about statistics, and it's deeply related to things we do every day. If you are comfortable writing code but sometimes intimidated (Open link)
Alfred lets you automate anything on your Mac. Chris Messina shows us how to set up Alfred and create desktop workflows to boost productivity. Chapters - St... (Open link)
For when people get too hyped up about things. Contribute to hwayne/awesome-cold-showers development by creating an account on GitHub. (Open link)
Python programs, usually short, of considerable difficulty, to perfect particular skills. - pytudes/Probability.ipynb at main · norvig/pytudes (Open link)
From the creators of DX, DORA, and SPACE. (Open link)
In the world of modern portable devices, it may be hard to believe that merely a few decades ago the most convenient way to keep track of time was a mechanical watch. Unlike their quartz and smart siblings, mechanical wa (Open link)
SSH port forwarding explained in a clean and visual way. How to use local and remote port forwarding. What sshd settings may need to be adjusted. How to memorize the right flags. (Open link)
By now, you have probably heard of OpenAI’s ChatGPT, or any of the alternatives GPT-3, GPT-4, Microsoft’s Bing Chat, Facebook’s LLaMa or even Google’s Bard. They are artificial intelligence programs that can participate (Open link)
59 votes, 31 comments. For those that have read the "The Climbing Bible: Technical, physical and mental training for rock climbing" by Martin … (Open link)
Design is the art of arranging code to work today, and be changeable forever. — Sandi Metz The last underlying principle I want to highlight is productivity. Developer productivity is a sprawling topic but it boils (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (199) | logout How to do the thing you've been avoiding (jasonfeifer.beehiiv.com) 514 points by duck 1 day ago | flag | hide | past | favori (Open link)
Search Scan Barcode Username: Password: Forgot your password? Log in Rambling Readers Read | Review | Discover DECENTRALIZED FRIENDLY ANTI-CORPORATE Rambling Readers is a friendly community of book lovers. You can tr (Open link)
A handful of mental models that, when combined, will provide a clear understanding of what is required to be a great engineering leader at different stages of your company. (Open link)
Leadership without management: the what, the how, the tools, and how to measure success as a Principal+ engineer. (Open link)
Generative Pre-trained Transformer models (GPTs) are now all the rage and have inspired op-eds being written by everyone from Henry Kissinger (WSJ) to Noam Chomsky (NYTimes) in just the last month. That sure is some hype (Open link)
Learn how to deploy a Go web application with Docker, and how Docker can help improve your development workflow and deployment process. (Open link)
Lessons from Facebook, Dropbox, and SPC on the singular importance of speed. (Open link)
Everything you need to know about monorepos, and the tools to build them. (Open link)
When Java 17 was released in 2021 as a “long term support” version, I wrote an article dissecting its features and came to the conclusion that it had a few nice features, but none that were compelling reasons to upgrade. (Open link)
Some years ago, I was explaining to my manager that I was feeling a bit bored, and they told me to learn how to read a Profit & Loss (P&L) statement. At the time, that sounded suspiciously like, “Stop wasting my time,” b (Open link)
What is a LAN? What is a network segment? Ethernet collision domains vs broadcast domains. How network switches work? How to send IP packets? VLAN vs VXLAN. (Open link)
As we collect various observability signals from systems, it fosters a new conversation around the classification of the signals. There is a significant discussion on observability signals and even… (Open link)
Vewing life as a game not only makes life a lot more fun, but it gives you tremendous insight into the human condition. (Open link)
Sample code and instructions for steps through different container image build options. - GitHub - maeddes/options-galore-container-build: Sample code and instructions for steps through different container image build op (Open link)
I never thought I’d be a watch person. (Or that I’d wear blue shorts.) I didn’t need a watch. I had a phone and a computer to tell me the time. But I got the Apple Watch on day one, because I’m a responsible iPhone app (Open link)
(Open link)
I have begun to notice a common blind spot among engineers who are frustrated about leveling up, which is: not every opportunity exists at every company at every time (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (199) | logout Guide to Software Architecture Documentation (workingsoftware.dev) 201 points by kiyanwang 11 hours ago | flag | hide | past (Open link)
6.824 Schedule: Spring 2021 TR1-2:30 Here is the tentative schedule of lectures and due dates. The lecture notes and paper questions for future dates are copies from previous years, and may change. The Zoom link for le (Open link)
SSH port forwarding explained in a clean and visual way. How to use local and remote port forwarding. What sshd settings may need to be adjusted. How to memorize the right flags. (Open link)
To find the best one-on-one games, we talked with experts and play-tested 20 high-rated titles. (Open link)
Building fairness into multitenant systems to provide predictable performance and availability (Open link)
Passkeys are a new way to log into websites and apps that replaces passwords. The industry-standard passkey technology is simpler and more secure than passwords (even with two-factor authentication), resists phishing, an (Open link)
Another factor, Mr. Stoppelman said, was a crucial decision, unusual at the time, to locate the company in a San Francisco office building instead of a Silicon Valley office park.“I’m not sure that Yelp would have succee (Open link)
Haruki Murakami interview: Haruki Murakami shares his views on myths, symbolism and post modernism, explains why cats and music make appearances in many of his books, and why he describes writing a novel as being in a (Open link)
KOTTKE.ORG ♥ HOME OF FINE HYPERTEXT PRODUCTS HOMEABOUTARCHIVEPODCASTNEWSLETTERMEMBERSHIP! A Demo of Pockit, a Tiny, Powerful, Modular Computer posted by Jason Kottke Mar 15, 2022 Admission time: it’s been a long t (Open link)
This is a simple checklist, and while it is useful to any software engineer, it is especially useful to senior engineers. More items from the list can be found here. (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (199) | logout Jazz Is Freedom (thebaffler.com) 93 points by ignored 14 hours ago | flag | hide | past | favorite | 56 comments navan (Open link)
All software applications are composed of re-usable elements. The objective and functionality of these reusable elements vary from infra level concern to security level concern to business… (Open link)
Software systems are increasingly based on data, rather than code. A new class of tools and technologies have emerged to process data for both analytics and ML. (Open link)
(Open link)
Much of expertise is tacit: that is, it cannot be captured through words alone. We look at techniques to learn the tacit knowledge of experts. (Open link)
JAVA LIBRARIES YOU CAN’T AFFORD TO MISS ANDRES ALMIRAY @AALMIRAY ANDRESALMIRAY.COM (Open link)
t(hink) l(earn); d(iscover) r(eason) (Open link)
In 2008, showbiz satire 30 Rock aired an episode called “MILF Island.” Poking fun at how tawdry reality television can be, it follows network honcho Jack Donaghy (Alec Baldwin) as he gloats about his newest hit, a realit (Open link)
"It's not who you are underneath, it's what you do that defines you." -Batman Begins (Open link)
(Open link)
Posted on Feb 8 2023 This year (2023) is the year of platform engineering. Don’t believe me? Here is the esteemed (and it has to be said lovely) Charles Humble totally accurately quoting the ravings of some madman o (Open link)
Ann Mehl and Jerry Colonna coach startups to communicate more clearly. These are the quick tips they've seen make a huge impact. (Open link)
A new tool that blends your everyday work apps into one. It's the all-in-one workspace for you and your team (Open link)
Learn how to choose carabiners for rock climbing, and the benefits of locking, nonlocking, wiregate, bent-gate and straight-gate carabiners. (Open link)
It isn’t exactly news that developers have to write not only code but also tests. Nevertheless, many find this to be burdensome and monotonous work. Plus, it is far from guaranteed that unit tests actually cover all the (Open link)
(Open link)
From sharing a cuppa to lazing in the park, is the key to happiness doing everyday activities with pals? (Open link)
Ever since I started to work on the Apache APISIX project, I’ve been trying to improve my knowledge and understanding of REST RESTful HTTP APIs. For this, I’m reading and watching the following sources: Books. At the mom (Open link)
Whether you implement or not microservices (and you probably shouldn’t), your system is most probably composed of multiple components. The most straightforward system is probably made of a reverse proxy, an app, and a da (Open link)
I’ve been reading up on observability over the last three months. In this post I have organized the material into a sort of recommended reading order. It doesn’t reflect the order in which I read it, but I think this ord (Open link)
Making Sense Of Single Action Lists In OmniFocus OmniFocus knows three different types of Projects: Sequential Projects, Parallel Projects and Single Action Lists. You would typically think that most... (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (199) | logout Bob Metcalfe wins Turing Award (acm.org) 831 points by robbiet480 1 day ago | flag | hide | past | favorite | 229 comments (Open link)
https://twitter.com/mipsytipsy/status/1309604622554640384 There are few engineering topics that provoke as much heated commentary as oncall. Everybody has a strong opinion. So let me say straight up that there are few if (Open link)
At most companies, people put together a deck, reserve a room (physical or virtual), and call a meeting to pitch a new idea. If they're lucky, no one interrupts them while they're presenting. When it's over, people react (Open link)
The handheld cellphone is 50 years old and has become an essential multi-tool that helps us run our lives. But is it altering the way our brains work? (Open link)
In distributed systems, logical clocks play a key role in the ordering of system events. What are the various logical clock designs, and how do they help with event ordering? This article answers these questions. (Open link)
Arthur C. Brooks and Lori Gottlieb discuss the importance of fun, the cultural distortion of emotions as “good” or “bad,” and how envy points you in the direction of your deepest desires. (Open link)
You can use this guide to understand what Java's Project loom is all about and how its virtual threads (also called 'fibers') work under the hood. (Open link)
(Open link)
Databricks, Snowflake, and the end of an overhyped era. (Open link)
I was a wayward kid who grew up on the literary side of life, treating math and science as if they were pustules from the plague. So it’s a little strange how I’ve ended up now—someone who dances daily with triple integr (Open link)
Merlin Mann attempts to capture the best advice he's heard and learned from. - wisdom/wisdom.md at master · merlinmann/wisdom (Open link)
HTML, CSS, JavaScript, Python, PHP, C++, Dart — there are so many programming languages out there and you may even be totally fluent in several of them! But (Open link)
When someone tells you that a particular video game (like Elden Ring) is hard, it can be tough to figure out what they might mean by that because games are hard in different ways. As Tolstoy might have said had he been a (Open link)
The smartest people in the world use mental models to make intelligent decisions, avoid stupidity, and increase productivity. Let's take a look at how ... (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Be Less Technical (sequential.dev) 141 points by 7237139812 8 days ago | flag | hide | past | favorite | 69 comments r (Open link)
Learn about the Java volatile keyword and its capabilities. (Open link)
The Dude looks back – and shares his behind-the-scenes photos – from the Coen brothers’ beloved take on L.A. noir (Open link)
Imagine you are buying a car. What essential features do you need in it? A vehicle should deliver a person from point A to point B. But what we also check in it is Safety, Comfort, Maintainability… (Open link)
Share your videos with friends, family, and the world (Open link)
A summary of Accelerated Expertise, the best book on accelerating training programs we have today. (Open link)
3.9m members in the programming community. Computer Programming (Open link)
HRV has long been used as an indicator of recovery and readiness in relation to endurance training, but what about correlations with your health? (Open link)
The Stronglifts 5×5 workout program is the simplest routine to get stronger and build muscle fast. Here’s how to get started with 5×5 training. (Open link)
Find out about the best ways to write subject lines for your cold sales emails to improve your open and response rates! This post is here to help you craft a subject line that appeals to your customers & is relevant to y (Open link)
Daniel Levy pins the great fire of 1835 as the birth event of modern Manhattan in a tale as teeming as the city itself (Open link)
This post is written by Luca Mezzalira, Principal Specialist Solutions Architect. Today, AWS is launching a preview of AWS Application Composer, a visual designer that you can use to build your serverless applica (Open link)
If you use retrospectives, or any kind of meeting where people are supposed to discuss and learn from their discussions, you will have experienced less efficient sessions from time to time. There is no wonder (Open link)
What are your core values? Whether yours need to be clarified or created from scratch, this is how to develop your defining values. (Open link)
Software projects are displayed by Gource as an animated tree with the root directory of the project at its centre. Directories appear as branches with files as leaves. Developers can be seen working on the tree at the t (Open link)
Seth Godin, the world-renowned marketing and leadership author inspires us on how to get our ideas spread when mass marketing and traditional advertising hav... (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Build Your Own Text Editor (2017) (viewsourcecode.org) 167 points by Tomte 10 hours ago | flag | hide | past | favorite | 18 (Open link)
For the past several years, I’ve run a learning circle with engineering executives. The most frequent topic that comes up is career management–what should I do next? The second most frequent topic is measuring engineerin (Open link)
Tech professionals’ pay by programming skills, job functions, regions, and more (Open link)
We know that we have built something which is genuinely useful: almost any team which adopts Slack as their central application for communication would be significantly better off than they were… (Open link)
Download PDF version Download list of components (Open link)
Often when an organization is going through some turmoil, executives think to themselves, “Ah, I should have some one-on-ones with the team so they can hear how we’re handling this.” On the other side, I frequently hear (Open link)
The history of Vi & Vim goes hand in hand with the history of open-source software. This article looks at the historical events that shaped the evolution of these text editors. (Open link)
“As the Nike slogan says: ‘Just do it.' Don’t wait around for inspiration," says psychology professor Tom Gilovich. (Open link)
Climbing shoes are very different from street shoes. Let's save you from the mistakes that most first-time buyers make. (Open link)
In a frank conversation, the Apple CEO offers new insight into his leadership—and explains how he has refashioned the world’s most creative company (from its privacy policy to its Oscar-winning movies to what’s coming ne (Open link)
I’d like to introduce you to a game I’ve been playing with friends for years. It’s not a game really—more of an exercise. The purpose is to add a bit more depth to the question, “Are you a good person?” Here’s how it’s p (Open link)
Most command line programs that offer line editing – like bash, Python, GDB, psql, sqlite and more – do so using GNU readline. Readline's a powerful library that grants history, completion, movement and editing to progra (Open link)
Copyright Disclaimer Under Section 107 of the Copyright Act 1976, allowance is made for fair use for purposes such as criticism, comment, news reporting, tea... (Open link)
Happy people express their gratitude for others. (Open link)
Professor Castleberry gives a lecture on Heidegger's Being-in-the-World (Open link)
Dark Sky, my weather app of choice for several years, is no more. This is sad, but I’ve done what any sensible person would and downloaded 12 weather apps from the App Store to find a suitable replacement on my iPhone (I (Open link)
Donald Knuth’s Annual Christmas Tree Lectures are back! 🌲✨ This year Dr. Knuth will present on Twintrees, Baxter Permutations, and Floorplans. Three fascina... (Open link)
JDK 21, the reference implementation of Java 21, is now Generally Available. We shipped build 35 as the first and only Release Candidate of JDK 21 on 11 August, and no P1 bugs have been reported since then. Build 35 is (Open link)
Learn how creativity works, how to find your hidden creative genius, and how to create meaningful work by learning how to make creative thinking a habit. (Open link)
Watch now (3 min) | No, I've always been good enough. (Open link)
Table of ContentsIntroductionAdviceInformal OverviewMemory ModelImplementation Restrictions for Programs Containing Data RacesSynchronizationInitializationGoroutine creationGoroutine destructionChannel communicationLocks (Open link)
By POM I mean Apache Maven's Project Object Model. The POM format is widely used not just by Apache Maven to build and consume projects, but also by other tools such as IDEs, build tools, code analyzers, etc. Understandi (Open link)
People don’t seem to try very hard to make themselves happier. Why not? (Open link)
Expand your development workflow with task integration in Visual Studio Code. (Open link)
You can use this guide to learn the basics of JDBC: How to connect to any database and execute SQL queries. (Open link)
From navigating code to debugging tests, building Go projects in VS Code has never been easier with the latest editor tools. This demo showcased how Go in V... (Open link)
How does the Apple Watch Ultra hold up as a premium sports watch vs. the Garmin Fenix 7, Epix, and Enduro 2? Here is what you should know! (Open link)
Advanced macOS command-line tools. (Open link)
We recently had the pleasure of participating in QCon, a global conference that gathers the best engineers from top-notch innovation companies. The event covers a wide range of relevant software… (Open link)
"If blood pressure is only measured while people are seated upright, cardiovascular disease risk may be missed," researchers warn. (Open link)
Back in 2019. At that time, I was deploying a data lake strategy inside Michelin and we had decided to build the main one as a platform to enable more data use case. I was having a coffee while reading my mail. In my box (Open link)
Level up your Java code and explore what Spring can do for you. (Open link)
(Open link)
Selecting the correct MTT* metric to improve your incident response is important. If the wrong metric is chosen, the improvements may get lost in the noise of a multivariable equation. (Open link)
All I wanted was a widget. A few days ago, as I was playing around with my Lock Screen on iOS 16, I wondered: would it be possible to use the hidden Apple Notes URL scheme to create widget launchers to reopen specific no (Open link)
What started as lighthearted iconoclasm, poking at the bear of SOLID, has developed into something more concrete and tangible. If I do not think the SOLID principles are useful these days, then what would I replace them (Open link)
How to use principles to enable autonomy and alignment in your team. (Open link)
how biotechnology will abolish suffering (Open link)
In French, “cultiver son jardin intérieur” means to tend to your internal garden—to take care of your mind. The garden metaphor is particularly apt: taking care of your mind involves cultivating your curiosity (the seeds (Open link)
Navigation Confluence Mobile Loading... (Open link)
(Open link)
What happens when the surreal imagination of the world’s greatest living animator, Hayao Miyazaki, is turned into a theme park? (Open link)
Your healing creates waves that are consciously and unconsciously felt by others. The vibration or energy that you emit reverberates outward and influences the environment and those in it. Your peace can be felt by other (Open link)
I first discovered sarcasm as a freshman in college, which I realize makes me a bit of a late bloomer as far as teenagers go. There were certain classmates who seemed to always come across as clever and funny no matter t (Open link)
JDK 15 was released on September 15, 2020. JEP 360 Sealed Types was included as a preview feature in this release. Sealed Types is part of Project Amber. Sealed classes or interfaces can be used to… (Open link)
Hacker News new | past | comments | ask | show | jobs | submit login Infrastructure SaaS – a control plane first architecture (thenile.dev) 56 points by infra_dev 4 hours ago | hide | past | favorite | 16 comments (Open link)
With billing, the devil is in the details. In this article, Raffi provides a high-level view of the technical challenges we faced while implementing a hybrid pricing (based on both 'subscription' and 'usage') at 5x unico (Open link)
Over recent months, tech companies have been laying workers off by the thousands. It is estimated that in 2022 alone, over 120,000 people have been dismissed from their job at some of the biggest players in tech – Meta, (Open link)
For the term "user space" as used in Wikipedia, see Wikipedia:User pages. "Kernel space" redirects here. For the mathematical definition, see Null space. This article needs additional citations for verification. Please h (Open link)
Speculative fiction readers will discover some hidden gems with this list of the best fantasy books you've never heard of. (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Slack’s Incident on 2-22-22 (slack.engineering) 286 points by alphabettsy 1 day ago | flag | hide | past | favorite | 165 com (Open link)
This article is about a few quick thumb rules I use when writing shell scripts that I’ve come to appreciate over the years. Very opinionated.... (Open link)
Issue 120: Manifesting through construction and assembly (Open link)
Uber’s backend is an exemplar of microservice architecture. Each microservice is a small, individually deployable program performing a specific business logic (operation). The microservice architecture is a type of distr (Open link)
Cancellation, Context, and Plumbing GothamGo 2014 Sameer Ajmani Video This tal (Open link)
A common situation we all face during a project is when we should compare two alternatives, for example, the most common for me is during performance analysis. Usual situations could range from evaluating the improvement (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout How to write more clearly, think more clearly, and learn complex material [pdf] (covingtoninnovations.com) 775 points by Secr (Open link)
I was very excited when Apple announced the Apple Watch Ultra this fall. I’ve been wearing an Apple Watch on my wrist nearly every day since they were first released seven years ago. What was so exciting about the Ultra (Open link)
Welcome to my blog! I am a final year student studying Electronic and Information Engineering at Imperial (Open link)
Based on experience gained from several microservices migrations, these seven lessons can help you be successful and overcome or avoid common challenges. (Open link)
(Open link)
Why is it so frickin hard to provide people with valuable feedback, let alone getting meaningful feedback from others? One of two things tends to be the case: we either don’t know how to ask for good feedback, or we don’ (Open link)
:wave: - The documentation for being an Artsy Engineer - artsy/README: - The documentation for being an Artsy Engineer (Open link)
It’s no secret that I’m not a fan of big-company HR practices. I’m more of the First Break all the Rules type. Despite my general skepticism of many standard practices, we still do annual performance reviews at my comp (Open link)
Resignations happen in a moment, and it’s not when you declare, “I’m resigning.” The moment happened a long time ago when you received a random email from a good friend who asked, “I know you’re really happy with your cu (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Evidence that life flashes before the eyes upon death (hyperallergic.com) 226 points by relaunched 8 days ago | flag | hide | (Open link)
Sapling supports large monorepos that have tens of millions of files and (Open link)
I'm trying some experimental tiers on Patreon to see if I can get to substack-like levels of financial support for this blog without moving to substack! A decade of major cache incidents at Twitter This was co-authored (Open link)
If you ask StackOverflow or ChatGPT, how to convert an InputStream to a String in Java, you get archaic constructs with buffered readers and tedious loops. In modern Java, you achieve this task and similar ones with a si (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (199) | logout Dotfiles Management (mitxela.com) 266 points by threeme3 16 hours ago | flag | hide | past | favorite | 112 comments p (Open link)
Investing in Lust, Pride, Sloth, Greed, Envy, Wrath, and Gluttony (Open link)
Decouple Capability and not Code Whenever developers want to extract a service out of an existing system, they have two ways to go about it: extract code or rewrite capability. Often by default the service extr (Open link)
The C4 model consists of a hierarchical set of software architecture diagrams. These diagrams are both easy to create and easy to understand for multiple intended audiences. (Open link)
This article explains how to use the www-authenticate header to handle user authentication without any client side code. (Open link)
In a way, an error message tells a story; and as with every good story, you need to establish some context about its general settings. For an error message, this should tell the recipient what the code in question was tr (Open link)
This is a four day Rust course developed by the Android team. The course covers the full spectrum of Rust, from basic syntax to advanced topics like generics and error handling. It also includes Android-specific content (Open link)
As long as it’s more than one person AND it’s important that we achieve some collective goal THEN we need some way of facilitating coherent action across an organisation. Without coherence, you’ll… (Open link)
I think the flow of time is not part of the fundamental structure of reality,” theoretical physicist Carlo Rovelli tells me. He is currently working on a theory of quantum gravity in which the variable of time plays no p (Open link)
(Open link)
Log in Sign up Ask Different is a question and answer site for power users of Apple hardware and software. It only takes a minute to sign up. Sign up to join this community Anybody can ask a question Anybody can answe (Open link)
Jack Kirby's son Neal released a blistering statement about Disney+'s Stan Lee documentary. (Open link)
Click to view our Accessibility Policy Skip to content Oracle Search Menu Resources for About Careers Developers Investors Partners Startups Why Oracle Analyst Reports Best CRM Cloud Economics Corporate Responsibility Di (Open link)
The Micronaut framework provides a solid foundation for building Cloud Native Java microservices. It reduces the use of Java reflection, runtime proxy generation, and dynamic classloading. (Open link)
From Java 8 to 18 (Open link)
Raycast API Search… ⌘K Introduction LINKS Community GitHub Store Icon Generator Extension Icon Template BASICS Getting Started Create Your First Extension Contribute to an Extension Prepare an Extension for Store Publish (Open link)
“To flash conviction on the mind.” (Open link)
Looking for some descriptive words for music? Is that types of music, sounds of music or effects of music? We have examples of them all, from folk to funk and tempo to timbre. (Open link)
New research shows that people with blue eyes have a single, common ancestor. Scientists have tracked down a genetic mutation which took place 6,000-10,000 years ago and is the cause of the eye color of all blue-eyed hum (Open link)
I’d like to introduce you to a game I’ve been playing with friends for years. It’s not a game really—more of an exercise. The purpose is to add a bit more depth to the question, “Are you a good person?” Here’s how it’s p (Open link)
Have you presented to company executives about a key engineering initiative, walking into the room excited and leaving defeated? Maybe you only made it to your second slide before unrelated questions derailed the discuss (Open link)
(Open link)
In 2019, to meet growth and availability challenges, we set a plan in motion to improve our tooling and ability to partition relational databases. (Open link)
A founder explores his journey with Acceptance and Commitment Therapy (ACT) (Open link)
People who are close to their colleagues are happier and more productive. (Open link)
Interested participants will learn what is currently going on in the development of Apache Maven 4.X. The goal is to get an Apache Maven version 4.0.0-alpha-... (Open link)
👨💻 For the price of $7.99 every month, sign up and gain access to a growing list of premium courses on my site - https://tutorialedge.net/pricing/ Welcome... (Open link)
A step by step guide for solving a difficult organizational problem, including notes on single stack ranks, team interdependencies, building consensus, reducing work in progress, and how to move your company towards bett (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (201) | logout Show HN: Every Breath You Take – Heart Rate Variability Training (github.com/kbre93) 290 points by kbre93 17 hours ago | flag (Open link)
Zhuangzi was the gadfly of ancient Chinese philosophy. His paradoxical writings encourage a stance of therapeutic scepticism towards the world. (Open link)
Command languages and scripting languages are and should be different things. (Open link)
Meetings are either a necessary evil or necessarily evil, depending on who you ask. Meetings are undeniably the most important tool for building a diverse, high-performance team with shared values. (Open link)
People get distracted, hit pause, never finish. It seems hopeless—but it’s not as dire as it sounds. (Open link)
The past, present, and future of writing on the internet (Open link)
Like tidying up a house before a total renovation, preparing your monolith is the first step towards transitioning to microservices. (Open link)
Related Resources Michael Nielsen on Twitter Michael Nielsen's project announcement mailing list cognitivemedium.com By Michael Nielsen One day in the mid-1920s, a Moscow newspaper (Open link)
A growing body of research suggests that the more we value and pursue happiness as a life goal, the more miserable we end up. (Open link)
Leading biologist tells Scott Pelley humans would need "five more Earths" to maintain our current way of life. (Open link)
Today, C may be a lingua franca among programmers. This is its (abridged) history. (Open link)
In this blog, you will learn some Docker best practices mainly focussed on Java applications. This is not only a theoretical exercise, but you will learn how to apply the best practices to your Dockerfiles. Enjoy! 1. Int (Open link)
Hacker News new | past | comments | ask | show | jobs | submit login How to do hard things (every.to/no-small-plans) 391 points by tacon 23 hours ago | hide | past | favorite | 127 comments ChrisMarshallNY 22 hour (Open link)
Two communicating processes on a single machine have a few options. They can use regular TCP sockets, UDP sockets, unix domain sockets, or shared memory. A recent project I was working on used Node.js with two communicat (Open link)
Personal website. (Open link)
Toward Joy and Durable Power in a Time of Crisis (Open link)
Skip to main content Online education by Particular Software Toggle menu MENU Welcome Back! EMAIL PASSWORD REMEMBER ME Forgot Password? If you are a human, ignore this field SIGN IN Create a new account HOME SUPPOR (Open link)
Be water, my friend (Open link)
Our comprehensive guide to CSS grid, focusing on all the settings both for the grid parent container and the grid child elements. (Open link)
For true contentment, adjust your approach. (Open link)
JavaOne is back! ➱ https://oracle.com/javaoneSequenced collections introduce an abstraction for collections with a known encounter order like all lists and... (Open link)
HAL is a simple way of linking in REST APIs with either JSON or XML. (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (194) | logout Study Tips from Richard Feynman (piggsboson.medium.com) 162 points by takiwatanga 13 hours ago | flag | hide | past | favorit (Open link)
When you're too focused on fixed goals, you're likely missing a lot. Flexible goals help you reach your goals and achieve happiness more. (Open link)
This story explores some concepts in computer networking, inspired by Michael Nielsen’s idea of discovery fiction. Code samples can also be found in this repo. Excerpts use openbsd-flavoured netcat on Debian Linux; behvi (Open link)
How do you convince someone who, for one reason or another, doesn’t see eye-to-eye with you? (Open link)
Ted Chiang on how artificial intelligence may strengthen capitalism by promising to concentrate wealth and disempower workers, and on possible alternatives. (Open link)
Hello guys, If you have given any coding interview then you know that System design or Software design problems are an important part of programming job interviews, and if you want to do well, you… (Open link)
iPadOS 16. At its keynote held earlier today online and, for a limited audience of developers and media, in Cupertino, Apple unveiled the next major versions of iOS and iPadOS: iOS 16 and iPadOS 16. Both OSes will be rel (Open link)
(Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout The Invention of Free Love (aeon.co) 25 points by pepys 4 hours ago | flag | hide | past | favorite | 8 comments cfigg (Open link)
The $86 billion global sneaker market has a new major player. Here’s how it happened. (Open link)
Welcome to engineering management. It’s fun, it’s exhausting, it’s rewarding — but most importantly it’s new! What worked for you before won’t work now. You’ll have to acquire a new set of skills, and shed some bad habit (Open link)
Agile emerged at a time when companies built and commonly released software in lengthy cycles of 6+ months. Each cycle had an explicit architecture or design phase involving more experienced developers, frequently named (Open link)
Have you ever found that you enter the week without a clear plan of action? Do you wish that you could articulate each team member’s role and responsibilities more clearly? In a dynamic, fast-paced… (Open link)
VS Code's new merge editor interface gives you the view you've been missing for easily resolving merge conflicts. 00:00 - Intro 00:30 - What is a merge conf... (Open link)
(Open link)
How do you measure service availability in modern web services? (Open link)
In this post, I hope to explore different forms of “testing in production”, when each form of testing is the most beneficial as well as how to test services in production in a safe way. However… (Open link)
We all believe we should exercise more. So why is it so hard to keep it up? Daniel E Lieberman, Harvard professor of evolutionary biology, explodes the most common and unhelpful workout myths. (Open link)
scc --exclude-dir docs/book ─────────────────────────────────────────────────────────────────────────────── Language Files Lines Blanks Comments Code Complexity ──────────────────────────────── (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (195) | logout Why is Booz Allen renting us back our own national parks? (mattstoller.substack.com) 381 points by PaulHoule 2 days ago | fla (Open link)
Hacker News new | threads | past | comments | ask | show | jobs | submit hanlec (194) | logout Learn about Concept Maps (ihmc.us) 56 points by Tomte 6 hours ago | flag | hide | past | favorite | 16 comments s_dev (Open link)
15 language-agnostic, actionable tips on REST API design. (Open link)
(Open link)
Understanding the difference between attach, logs, run, and exec commands through learning the container management internals. (Open link)
(Open link)
It's simpler, more compact, and reusable from year-to-year in a way that no other calendar is. Here's both how it works and how to use it. (Open link)
Resilience is coping with unexpected events and environmental change. To have resilience, you need slack. Slack in software development lets people do the little tasks that keep the work moving smoothly. That helps with (Open link)
Around the end of high school, I started to get really into photography. My friend (let's call him T) was also into it, which should have been great fun. But it wasn't. Going shooting with him was never great, for a reas (Open link)
You’ve probably never heard of a blurgit or a swalloop or a grawlix or an agitron, but you see them every day in your newspaper’s comics section. Here’s a primer on the secret language of comic symbols. (Open link)
June Picks: The Movies and TV You Can't Miss (Open link)
Table of Contents Intro Why Flagger Prerequisites NGINX (Ingress) Canary Deployment Try it out Linkerd (ServiceMesh) Canary Deployment with Ingress support Try it out Summary Intro Lately, I’ve been checkin (Open link)
The layered architecture pattern is one of the most common patterns. The idea behind a Layered pattern is that components with the same functionalities will be organized into horizontal layers. As a… (Open link)
"To fear or not to fear?" Alex Honnold and Armita Golkar discuss fear, risk, rock climbing and psychology in this discussion moderated by Carin Klaesson, cur... (Open link)
Software engineers are attracted to formulas, algorithms, and structures. As people whose job it is to take ideas and turn them into predictable executable code, it is unsurprising that we’re drawn… (Open link)
Skip to content JOHANNA PIRKER THE BLOG OF JOHANNA PIRKER HLF16: LISKOV’S READING LIST FOR COMPUTER SCIENTISTS by JohannaPosted on23. September 2016 Barbara Liskov pointed us in her talk at Heidelberg L (Open link)
In a way, an error message tells a story; and as with every good story, you need to establish some context about its general settings. For an error message, this should tell the recipient what the code in question was tr (Open link)
The AWS Well-Architected Framework defines resilience as “the capability to recover when stressed by load (more requests for service), attacks (either accidental through a bug, or deliberate through intention), and failu (Open link)
(Open link)
Interactive article explaining how GPS works. (Open link)
This best-practices article intends for developers interested in creating RESTful Web services that provide high reliability and consistency across multiple service suites; following these… (Open link)
Updates about my life and what I learn about creating software (Open link)
Explore Colorado Springs' awe-Inspiring National Natural Landmark, Garden of the Gods! Learn, explore, and sightsee at this amazing park. (Open link)
SpaceWall wallpapers. For this week’s special issue of MacStories Weekly to celebrate Week 2 of Automation April, I dusted off an old shortcut of mine and updated it for the modern era of Shortcuts automations and the ab (Open link)
Being a creature of habit, I don’t tend to change up my tech routine very often. Once I find a workflow that clicks for me, I usually stick with it. Why fix what isn’t broken? But lately, for one reason or another, I’ve (Open link)
In practice, computer code is constantly being transformed. At the beginning of a project, the computer code often takes the form of sketches that are gradually refined. Later, the code can be optimized or corrected, som (Open link)
Hacker News new | past | comments | ask | show | jobs | submit login How to put machine learning models into production (stackoverflow.blog) 120 points by Aaronmacaron 8 days ago | hide | past | favorite | 34 comments (Open link)
Exit Interviews ask why people are leaving, and Stay Interviews ask why they keep working here. (Open link)
More than 2 years ago, I decided to try to create a brief, digestible manual on the expectations of management for senior engineers at my company who are considering making the shift. At the time, I had about 3 years of (Open link)
Go 1, the first stable release of Go, came with a compatibility promise. This talk will explain why that's important, what it does and doesn't mean, and the ... (Open link)
Data scientists excel at creating models that represent and predict real-world data, but effectively deploying machine learning models is more of an art than science. Deployment requires skills more commonly found in sof (Open link)
(Open link)
When is the last time your iPhone truly surprised you? The answer to this question is a fascinating Rorschach test that can say a lot about a person’s relationship with Apple’s mobile platform. Some might say it was over (Open link)
How container networking works under the hood? Setting up docker-like container networking from scratch. Bonus: podman rootless container networking explained. (Open link)
A new field of psychology is quantifying how awe can improve our physical and mental health. (Open link)
Last month, I wanted to better understand into how leaders manage their time and attention. While this seems like a core leadership skill, a lot of the managers I know have a fractious relationship with productivity tool (Open link)
Software is rarely designed in isolation. It doesn't happen by one person going away in their corner for some time, then coming back with a thoroughly thought-out map of what to build and how. And as they explain the app (Open link)
Welcome to the third interview on 'The Observer Effect'. We are lucky to have one of the most interesting founders in technology and commerce - Tobi Lütke, Founder and CEO of Shopify. This interview was (Open link)
Quintin Middleton's story is one of a kind. (Open link)
The "Gonzo fist", characterized by two thumbs and four fingers holding a peyote button, was originally used in Hunter S. Thompson's 1970 campaign for sheriff of Pitkin County, Colorado. It has since evolved into a symbol (Open link)
I am an ecocritic, a critic of culture’s relationship to nature, and when I present my work on Hayao Miyazaki at academic conferences, Japanese scholars inevitably ask why I am the only American at the conference doing s (Open link)
The GOVNO framework is a novel approach to project management that aims to improve upon the shortcomings of the popular scrum methodology. Each letter of the acronym represents a key aspect of the framework: G: Governan (Open link)
In this post, learn how relational and NoSQL databases, Google Cloud Spanner and DataStax Astra DB, optimize distributed joins for real-time applications. Distributed joins are commonly considered to… (Open link)
A step-by-step guide on improving your homepage content & copy to increase conversion (Open link)
Quarkus truly appears to be the smartest possible solution, in our experience. (Open link)
AWS Lake Formation (coming soon) will make it easy to set up a secure data lake in days. With AWS Lake Formation, you will be able to ingest, catalog, clean, transform, and secure your data, and make it available for ana (Open link)
Credit: Comfreak / Pixabay By now, we’ve all heard of the great resignation. Over the past 18 months or so, many people have had more time to think about what they want from their jobs, and the kind of conditions they (Open link)
After needing to do a deep dive on the venv module (which I will explain later in this blog post as to why), I thought I would explain how virtual environments work to help demystify them.Back in my the day, there was no (Open link)
Frequently we will be given problems to solve by other people. Early in our career, these problems will usually be well-scoped and specific, eg: And as we grow as engineers these tasks become bigger… (Open link)
BESIDE: Bridging the gap between humans and nature (Open link)
(Open link)
Microservices show where Java lags behind other languages. Reactive programming provides a concise DSL to express the movement of state and to write concurrent, multithreaded code with better scaling. (Open link)
I previously wrote about starting a Go project in 2018. A lot has changed since I wrote that and I had been wanting to write an updated version. What follows should be enough for anyone new to Go to get started and ideal (Open link)
And what do we even mean when we say “technical”? (Open link)
This time of the year always excites us: it brings a look at what’s new in iPhone photography. First up is our brief look at the technical specifications of the new iPhone 14 Pro cameras. Our next post field tests the n (Open link)
Since we started PostHog, our team has interviewed 725 people. What's one thing I've taken from this? It's normal for candidates not to ask harder… (Open link)
What happens when your distributed service has challenges with stampeding herds of internal requests? How do you prevent cascading failures between internal services? How might you re-architect your workflows when naive (Open link)
July 2023 If you collected lists of techniques for doing great work in a lot of different fields, what would the intersection look like? I decided to find out by making it. Partly my goal was to create a guide that cou (Open link)
There is something delightful about riding a bicycle. Once mastered, the simple action of pedaling to move forward and turning the handlebars to steer makes bike riding an effortless activity. In the demonstration below, (Open link)
Hundreds of companies have no access to JIRA, Confluence and Atlassian Cloud. What can engineering teams learn from the poor handling of this outage? (Open link)
Reading the thought-provoking "Patterns & Abstractions" post reminded me of a long-held opinion I have about programming language design: we have a tendency to keep adding features to a language until it becomes so big (Open link)
Skip to content Home Learning Programs Calendar Resources About Us Contact Fun & Innovative Search Trends For Software Development in 2023 11 Jan 2023 / Alex Bolboaca / No Comments Happy New Year 2023 everyone! Since it (Open link)
When I started my journey at LinkedIn ten years ago, the company was just beginning to experience extreme growth in the volume, variety, and velocity of our data. Over the next few years, my colleagues and I in LinkedIn’ (Open link)
This is Part One (of two) of our story chronicling Twitch’s journey from monolithic architecture to microservices. In Part One, you’ll learn about our early days, from our rapid growth to the perfo... (Open link)
In 1952, the Sight and Sound team had the novel idea of asking critics to name the greatest films of all time. The tradition became decennial, increasing in size and prestige as the decades passed. The Sight and So (Open link)
We continue building our microservices system by adding a coordination layer to handle spinning multiple services up and down. (Open link)
Many apps today are actually a front-end for a series of API calls. APIs are necessary to proper functioning of such applications, but if you don’t protect them, bad actors can exfiltrate data, DDoS your servers, or othe (Open link)
Always blaming yourself or assuming others think ill of you? A CBT therapist shares ways to break these self-critical habits (Open link)
Is subvocalization keeping you from becoming a faster reader? Here's what the science says — and how to actually increase your reading speed. (Open link)
Organizations are re-architecting their traditional monolithic applications to incorporate microservices. This helps them gain agility and scalability and accelerate time-to-market for new features. Each microser (Open link)
From Java 8 to 17 (Open link)
A beautiful program to read your RSS feeds right in the terminal! - GitHub - TypicalAM/goread: A beautiful program to read your RSS feeds right in the terminal! (Open link)
Get your spending in line with this innovative way to save money. (Open link)
My Obsidian workflow - mnml's vault - Powered by Obsidian Publish. (Open link)
There is something legendary and historic happening in software engineering, right now as we speak, and yet most of you don’t realize at all how big it is. (Open link)
There is something about age and experience that shines a powerful light on the absurdity of life. It’s as if, after enough trips around the sun, we begin to see patterns of history repeating itself… (Open link)
Viorel Spînu My technical expertise Thought to put together some of the technologies I've been used so far. Came up below timeline. Seems the last few years I had a lot of free time :) Click to enlarge. BACKEND (Open link)
Share your videos with friends, family, and the world (Open link)
I have watched many many TV series. All of them I’ve tried to memorize in some extent. Just for pleasure of being able to rewatch some scenes and recall episodes in order, and thus not forget them, but also for using the (Open link)
The need for ad-hoc real-time data analysis has been growing at Uber. They run a large Apache Kafka deployment and need to analyse data going through the many workflows it supports. Solutions like str (Open link)
A collection of articles on common problems startups face when scaling. 16 March 2022 Tim Cochran, Carl Nygard, and Roni Smith Accumulation of tech debt; experiments and shortcuts are core components Thro (Open link)
https://media.ccc.de/v/rc3-channels-2020-20-what-have-we-lost-We have ended up in a world where UNIX and Windows have taken over, and most people have never ... (Open link)